First commit

.dockerignore

@@ -0,0 +1,37 @@
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+*.egg-info/
+dist/
+build/
+
+# Virtual environments (but not in backend/)
+**/.venv/
+**/venv/
+**/ENV/
+**/env/
+
+# IDE
+.vscode/
+.idea/
+*.swp
+*.swo
+*~
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Git
+.git/
+.gitignore
+
+# Tests
+tests/
+*.egg-info/
+
+# Lock files
+uv.lock

.idea/.gitignore

@@ -0,0 +1,8 @@
+# Default ignored files
+/shelf/
+/workspace.xml
+# Editor-based HTTP Client requests
+/httpRequests/
+# Datasource local storage ignored files
+/dataSources/
+/dataSources.local.xml

.idea/copilot.data.migration.agent.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="AgentMigrationStateService">
+    <option name="migrationStatus" value="COMPLETED" />
+  </component>
+</project>

.idea/copilot.data.migration.ask.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="AskMigrationStateService">
+    <option name="migrationStatus" value="COMPLETED" />
+  </component>
+</project>

.idea/copilot.data.migration.ask2agent.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="Ask2AgentMigrationStateService">
+    <option name="migrationStatus" value="COMPLETED" />
+  </component>
+</project>

.idea/copilot.data.migration.edit.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="EditMigrationStateService">
+    <option name="migrationStatus" value="COMPLETED" />
+  </component>
+</project>

.idea/inspectionProfiles/Project_Default.xml

@@ -0,0 +1,6 @@
+<component name="InspectionProjectProfileManager">
+  <profile version="1.0">
+    <option name="myName" value="Project Default" />
+    <inspection_tool class="Eslint" enabled="true" level="WARNING" enabled_by_default="true" />
+  </profile>
+</component>

.idea/misc.xml

@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="KubernetesApiProvider">{}</component>
+</project>

.idea/modules.xml

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ProjectModuleManager">
+    <modules>
+      <module fileurl="file://$PROJECT_DIR$/.idea/rmscript_space_demo.iml" filepath="$PROJECT_DIR$/.idea/rmscript_space_demo.iml" />
+    </modules>
+  </component>
+</project>

.idea/rmscript_space_demo.iml

@@ -0,0 +1,12 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module type="WEB_MODULE" version="4">
+  <component name="NewModuleRootManager">
+    <content url="file://$MODULE_DIR$">
+      <excludeFolder url="file://$MODULE_DIR$/.tmp" />
+      <excludeFolder url="file://$MODULE_DIR$/temp" />
+      <excludeFolder url="file://$MODULE_DIR$/tmp" />
+    </content>
+    <orderEntry type="inheritedJdk" />
+    <orderEntry type="sourceFolder" forTests="false" />
+  </component>
+</module>

.idea/vcs.xml

@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="VcsDirectoryMappings">
+    <mapping directory="$PROJECT_DIR$" vcs="Git" />
+    <mapping directory="$PROJECT_DIR$/reachy_mini" vcs="Git" />
+  </component>
+</project>

Dockerfile

@@ -0,0 +1,38 @@
+# Dockerfile for RMScript Web Demo on HuggingFace Spaces
+FROM python:3.11-slim
+
+# Set working directory
+WORKDIR /app
+
+# Install system dependencies
+RUN apt-get update && apt-get install -y \
+    build-essential \
+    && rm -rf /var/lib/apt/lists/*
+
+# Copy reachy_mini package source (dependency of rmscript)
+COPY reachy_mini/ /app/reachy_mini/
+
+# Install reachy_mini package
+RUN pip install --no-cache-dir /app/reachy_mini
+
+# Copy rmscript package source
+COPY rmscript/ /app/rmscript/
+
+# Install rmscript package with dependencies
+RUN pip install --no-cache-dir /app/rmscript[scipy]
+
+# Copy backend code
+COPY backend/ /app/backend/
+
+# Install backend dependencies
+WORKDIR /app/backend
+RUN pip install --no-cache-dir fastapi uvicorn[standard] pydantic
+
+# Copy frontend code
+COPY frontend/ /app/frontend/
+
+# Expose port 7860 (required by HuggingFace Spaces)
+EXPOSE 7860
+
+# Run the FastAPI server
+CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "7860"]

README.md

@@ -0,0 +1,111 @@
+---
+title: RMScript Web Demo
+emoji: 🤖
+colorFrom: purple
+colorTo: blue
+sdk: docker
+app_port: 7860
+pinned: false
+---
+
+# RMScript Web Demo
+
+Web-based IDE for writing, verifying, and executing rmscript code on Reachy Mini.
+
+## Architecture
+
+- **Frontend** (`frontend/`): HTML/CSS/JavaScript editor with live compilation and robot control
+- **Backend** (`backend/`): FastAPI server for rmscript compilation and validation
+- **Robot**: Reachy Mini robot daemon running on localhost:8000
+
+## Quick Start
+
+### On HuggingFace Spaces
+
+Just open the Space - the web IDE will load automatically.
+
+**Requirements:**
+- Reachy Mini daemon running on `localhost:8000` on your local machine
+- Modern web browser with WebSocket support
+
+### Local Development
+
+1. Install rmscript package:
+```bash
+cd rmscript
+uv sync
+```
+
+2. Start backend server:
+```bash
+cd backend
+uv sync
+uv run python app.py
+```
+
+3. Make sure your Reachy Mini daemon is running on `localhost:8000`
+
+4. Open `frontend/index.html` in your web browser
+
+## Features
+
+- **Code Editor**: Write rmscript with syntax examples
+- **Verify Button**: Check script validity without executing
+- **Execute Button**: Compile and run script on connected robot
+- **Live Compilation**: See IR (Intermediate Representation) of your script
+- **Example Scripts**: Load pre-written examples (basic, complex, repeat)
+- **Real-time Logging**: Console shows compilation errors, warnings, and execution progress
+
+## Usage
+
+1. Write rmscript in the editor (or load an example)
+2. Click "Verify" to check syntax and semantics
+3. Review any errors/warnings in the console
+4. Click "Execute" to run on the robot (robot must be connected)
+5. Watch execution progress in the Execution Info panel
+
+## Current Limitations
+
+- Sound and picture actions are not yet implemented in execution
+
+## Deployment to HuggingFace Spaces
+
+To deploy this demo to HuggingFace Spaces:
+
+1. **Prepare the repository structure:**
+   - Copy the `rmscript` and `reachy_mini` directories into the `rmscript_space_demo` directory:
+     ```bash
+     cd rmscript_space_demo
+     cp -r ../rmscript ./rmscript
+     cp -r ../reachy_mini ./reachy_mini
+     ```
+   - Your structure should be:
+     ```
+     rmscript_space_demo/
+       ├── Dockerfile
+       ├── README.md
+       ├── .dockerignore
+       ├── backend/
+       ├── frontend/
+       ├── rmscript/     ← copied source
+       └── reachy_mini/  ← copied source (dependency)
+     ```
+
+2. **Create a new Space:**
+   - Go to https://huggingface.co/new-space
+   - Select "Docker" as the SDK
+   - Push this directory to your Space repository
+
+3. **The Space will:**
+   - Build the Docker container
+   - Install rmscript and dependencies
+   - Serve the web IDE on port 7860
+
+**Note:** The Space connects to your local robot daemon on `localhost:8000`. Make sure it's running when using the demo.
+
+## Development
+
+To modify the demo:
+- Frontend code: `frontend/app.js`
+- Backend API: `backend/app.py`
+- Styling: `frontend/index.html` (embedded CSS)

backend/README.md

@@ -0,0 +1,44 @@
+# RMScript Web Demo - Backend
+
+FastAPI backend for compiling and validating rmscript code.
+
+## Installation
+
+```bash
+# Install dependencies with uv
+uv sync
+```
+
+## Running
+
+```bash
+uv run python app.py
+```
+
+Or with uvicorn directly:
+
+```bash
+uv run uvicorn app:app --reload --port 8001
+```
+
+The API will be available at http://localhost:8001
+
+## API Endpoints
+
+- `GET /` - API information
+- `POST /api/verify` - Verify rmscript syntax (returns errors/warnings)
+- `POST /api/compile` - Compile rmscript to IR (returns IR actions)
+
+## Example Usage
+
+```bash
+# Verify a script
+curl -X POST http://localhost:8001/api/verify \
+  -H "Content-Type: application/json" \
+  -d '{"source": "look left\nwait 1s\nlook right"}'
+
+# Compile a script
+curl -X POST http://localhost:8001/api/compile \
+  -H "Content-Type: application/json" \
+  -d '{"source": "look left\nwait 1s\nlook right"}'
+```

backend/app.py

@@ -0,0 +1,252 @@
+"""FastAPI backend for rmscript web demo."""
+
+import logging
+from pathlib import Path
+from typing import Any, Dict, List
+from fastapi import FastAPI, HTTPException
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import FileResponse
+from fastapi.staticfiles import StaticFiles
+from pydantic import BaseModel
+
+from rmscript import compile_script
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+# Create FastAPI app
+app = FastAPI(
+    title="RMScript Web Demo API",
+    description="Backend API for compiling and validating rmscript code",
+    version="1.0.0"
+)
+
+# Enable CORS for local development
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],  # In production, specify exact origins
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Set up paths for serving frontend
+BACKEND_DIR = Path(__file__).parent
+FRONTEND_DIR = BACKEND_DIR.parent / "frontend"
+
+# Mount static files (CSS, JS)
+if FRONTEND_DIR.exists():
+    app.mount("/static", StaticFiles(directory=str(FRONTEND_DIR)), name="static")
+
+
+class ScriptInput(BaseModel):
+    """Input model for script compilation."""
+
+    source: str
+
+
+class CompilationError(BaseModel):
+    """Compilation error model."""
+
+    line: int
+    column: int
+    message: str
+    severity: str
+
+
+class VerifyResponse(BaseModel):
+    """Response model for script verification."""
+
+    success: bool
+    errors: List[Dict[str, Any]]
+    warnings: List[Dict[str, Any]]
+    name: str = ""
+    description: str = ""
+
+
+class IRActionModel(BaseModel):
+    """Simplified IR action model for JSON serialization."""
+
+    type: str  # "action", "wait", "picture", "sound"
+    duration: float = 0.0
+    # For movement actions
+    head_pose: List[List[float]] | None = None  # 4x4 matrix as nested list
+    antennas: List[float] | None = None  # [left, right] in radians
+    body_yaw: float | None = None  # radians
+    # For sound actions
+    sound_name: str | None = None
+    blocking: bool = False
+    loop: bool = False
+    # Metadata
+    source_line: int = 0
+
+
+class CompileResponse(BaseModel):
+    """Response model for script compilation."""
+
+    success: bool
+    errors: List[Dict[str, Any]]
+    warnings: List[Dict[str, Any]]
+    name: str = ""
+    description: str = ""
+    ir: List[IRActionModel]
+
+
+@app.get("/")
+async def root():
+    """Serve the frontend application."""
+    index_path = FRONTEND_DIR / "index.html"
+    if index_path.exists():
+        return FileResponse(index_path)
+    return {
+        "name": "RMScript Web Demo API",
+        "version": "1.0.0",
+        "endpoints": {
+            "/api/verify": "POST - Verify rmscript syntax and semantics",
+            "/api/compile": "POST - Compile rmscript to IR",
+        }
+    }
+
+
+@app.post("/api/verify", response_model=VerifyResponse)
+async def verify_script(input: ScriptInput):
+    """Verify rmscript without generating IR.
+
+    Args:
+        input: Script source code
+
+    Returns:
+        Verification result with errors and warnings
+
+    """
+    logger.info(f"Verifying script ({len(input.source)} chars)")
+
+    try:
+        result = compile_script(input.source)
+
+        # Convert errors and warnings to dict format
+        errors = [
+            {
+                "line": e.line,
+                "column": e.column,
+                "message": e.message,
+                "severity": e.severity
+            }
+            for e in result.errors
+        ]
+
+        warnings = [
+            {
+                "line": w.line,
+                "column": w.column,
+                "message": w.message,
+                "severity": w.severity
+            }
+            for w in result.warnings
+        ]
+
+        return VerifyResponse(
+            success=result.success,
+            errors=errors,
+            warnings=warnings,
+            name=result.name,
+            description=result.description
+        )
+
+    except Exception as e:
+        logger.error(f"Verification error: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@app.post("/api/compile", response_model=CompileResponse)
+async def compile_rmscript(input: ScriptInput):
+    """Compile rmscript to intermediate representation.
+
+    Args:
+        input: Script source code
+
+    Returns:
+        Compilation result with IR
+
+    """
+    logger.info(f"Compiling script ({len(input.source)} chars)")
+
+    try:
+        from rmscript.ir import IRAction, IRWaitAction, IRPictureAction, IRPlaySoundAction
+
+        result = compile_script(input.source)
+
+        # Convert errors and warnings to dict format
+        errors = [
+            {
+                "line": e.line,
+                "column": e.column,
+                "message": e.message,
+                "severity": e.severity
+            }
+            for e in result.errors
+        ]
+
+        warnings = [
+            {
+                "line": w.line,
+                "column": w.column,
+                "message": w.message,
+                "severity": w.severity
+            }
+            for w in result.warnings
+        ]
+
+        # Convert IR to JSON-serializable format
+        ir_json = []
+        for action in result.ir:
+            if isinstance(action, IRAction):
+                ir_json.append(IRActionModel(
+                    type="action",
+                    duration=action.duration,
+                    head_pose=action.head_pose.tolist() if action.head_pose is not None else None,
+                    antennas=action.antennas if action.antennas is not None else None,
+                    body_yaw=action.body_yaw,
+                    source_line=action.source_line
+                ))
+            elif isinstance(action, IRWaitAction):
+                ir_json.append(IRActionModel(
+                    type="wait",
+                    duration=action.duration,
+                    source_line=action.source_line
+                ))
+            elif isinstance(action, IRPictureAction):
+                ir_json.append(IRActionModel(
+                    type="picture",
+                    source_line=action.source_line
+                ))
+            elif isinstance(action, IRPlaySoundAction):
+                ir_json.append(IRActionModel(
+                    type="sound",
+                    duration=action.duration or 0.0,
+                    sound_name=action.sound_name,
+                    blocking=action.blocking,
+                    loop=action.loop,
+                    source_line=action.source_line
+                ))
+
+        logger.info(f"Compiled {len(ir_json)} IR actions")
+
+        return CompileResponse(
+            success=result.success,
+            errors=errors,
+            warnings=warnings,
+            name=result.name,
+            description=result.description,
+            ir=ir_json
+        )
+
+    except Exception as e:
+        logger.error(f"Compilation error: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(app, host="0.0.0.0", port=8001, log_level="info")

backend/pyproject.toml

@@ -0,0 +1,14 @@
+[build-system]
+requires = ["setuptools"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "rmscript-web-backend"
+version = "1.0.0"
+requires-python = ">=3.11"
+dependencies = [
+    "fastapi>=0.104.0",
+    "uvicorn[standard]>=0.24.0",
+    "pydantic>=2.4.0",
+    "rmscript[reachy,scipy] @ file:///Users/david/projects/reachy-mini/rmscript",
+]

backend/requirements.txt

@@ -0,0 +1,4 @@
+fastapi>=0.104.0
+uvicorn[standard]>=0.24.0
+pydantic>=2.4.0
+rmscript>=0.1.0

frontend/app.js

@@ -0,0 +1,436 @@
+// RMScript Web Demo - Frontend Application
+// Connects to:
+// - Backend API for compilation/verification
+// - Robot WebSocket (localhost:8000) for execution
+
+// Auto-detect backend URL based on environment
+// If opened as file:// (local development), use localhost:8001
+// If served from web server (production/Space), use relative URLs
+const BACKEND_URL = window.location.protocol === 'file:'
+    ? 'http://localhost:8001'
+    : '';  // Use relative URLs when served from web server
+const ROBOT_WS_URL = 'ws://localhost:8000/api/move/ws/set_target';
+
+// Global state
+const state = {
+    robotWs: null,
+    robotConnected: false,
+    currentIR: null,
+    isExecuting: false
+};
+
+// DOM elements
+const elements = {
+    editor: document.getElementById('editor'),
+    compileStatus: document.getElementById('compileStatus'),
+    robotStatus: document.getElementById('robotStatus'),
+    console: document.getElementById('console'),
+    irDisplay: document.getElementById('irDisplay'),
+    executionInfo: document.getElementById('executionInfo'),
+    executeBtn: document.getElementById('executeBtn')
+};
+
+// Example scripts
+const examples = {
+    basic: `DESCRIPTION Simple head movement
+look left
+wait 1s
+look right
+wait 1s
+look center`,
+
+    complex: `DESCRIPTION Wave hello
+look left
+antenna both up
+wait 1s
+look right
+antenna both down
+wait 0.5s
+look center`,
+
+    repeat: `DESCRIPTION Repeat demo
+REPEAT 3
+  look left
+  wait 0.5s
+  look right
+  wait 0.5s
+END
+look center`
+};
+
+// Initialize robot WebSocket connection
+function connectRobotWebSocket() {
+    log('Connecting to robot...', 'info');
+
+    state.robotWs = new WebSocket(ROBOT_WS_URL);
+
+    state.robotWs.onopen = () => {
+        state.robotConnected = true;
+        updateRobotStatus(true);
+        log('Robot connected!', 'success');
+    };
+
+    state.robotWs.onclose = () => {
+        state.robotConnected = false;
+        updateRobotStatus(false);
+        log('Robot disconnected. Reconnecting...', 'warning');
+        setTimeout(connectRobotWebSocket, 2000);
+    };
+
+    state.robotWs.onerror = (error) => {
+        log(`Robot connection error: ${error}`, 'error');
+    };
+
+    state.robotWs.onmessage = (event) => {
+        try {
+            const message = JSON.parse(event.data);
+            if (message.status === 'error') {
+                log(`Robot error: ${message.detail}`, 'error');
+            }
+        } catch (e) {
+            console.error('Failed to parse robot message:', e);
+        }
+    };
+}
+
+// Update robot connection status UI
+function updateRobotStatus(connected) {
+    if (connected) {
+        elements.robotStatus.className = 'status connected';
+        elements.robotStatus.innerHTML = '<span><span class="status-dot green"></span>Connected</span>';
+        elements.executeBtn.disabled = false;
+    } else {
+        elements.robotStatus.className = 'status disconnected';
+        elements.robotStatus.innerHTML = '<span><span class="status-dot red"></span>Disconnected</span>';
+        elements.executeBtn.disabled = true;
+    }
+}
+
+// Update compile status UI
+function updateCompileStatus(status, message) {
+    const dot = status === 'success' ? 'green' : status === 'error' ? 'red' : 'gray';
+    elements.compileStatus.className = `status ${status}`;
+    elements.compileStatus.innerHTML = `<span><span class="status-dot ${dot}"></span>${message}</span>`;
+}
+
+// Log to console
+function log(message, type = 'info') {
+    const line = document.createElement('div');
+    line.className = `console-line ${type}`;
+    line.textContent = `[${new Date().toLocaleTimeString()}] ${message}`;
+    elements.console.appendChild(line);
+    elements.console.scrollTop = elements.console.scrollHeight;
+}
+
+// Clear console
+function clearConsole() {
+    elements.console.innerHTML = '';
+}
+
+// Load example script
+function loadExample(exampleName) {
+    if (examples[exampleName]) {
+        elements.editor.value = examples[exampleName];
+        log(`Loaded ${exampleName} example`, 'info');
+    }
+}
+
+// Clear editor
+function clearEditor() {
+    elements.editor.value = '';
+    state.currentIR = null;
+    elements.irDisplay.innerHTML = '<div style="color: #999; text-align: center; padding: 20px;">No IR yet. Verify a script first!</div>';
+    updateCompileStatus('idle', 'Ready');
+}
+
+// Verify script (syntax and semantics only)
+async function verifyScript() {
+    const source = elements.editor.value.trim();
+
+    if (!source) {
+        log('Editor is empty', 'warning');
+        return;
+    }
+
+    clearConsole();
+    log('Verifying script...', 'info');
+    updateCompileStatus('idle', 'Verifying...');
+
+    try {
+        const response = await fetch(`${BACKEND_URL}/api/verify`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ source })
+        });
+
+        const result = await response.json();
+
+        if (result.success) {
+            log('✓ Verification successful!', 'success');
+            if (result.name) log(`  Name: ${result.name}`, 'info');
+            if (result.description) log(`  Description: ${result.description}`, 'info');
+
+            if (result.warnings.length > 0) {
+                result.warnings.forEach(w => {
+                    log(`  Warning (line ${w.line}): ${w.message}`, 'warning');
+                });
+            }
+
+            updateCompileStatus('success', 'Valid script');
+        } else {
+            log('✗ Verification failed', 'error');
+            result.errors.forEach(e => {
+                log(`  Error (line ${e.line}): ${e.message}`, 'error');
+            });
+            updateCompileStatus('error', 'Invalid script');
+        }
+    } catch (error) {
+        log(`Backend error: ${error.message}`, 'error');
+        updateCompileStatus('error', 'Backend error');
+    }
+}
+
+// Compile script to IR
+async function compileScript() {
+    const source = elements.editor.value.trim();
+
+    if (!source) {
+        log('Editor is empty', 'warning');
+        return null;
+    }
+
+    log('Compiling script to IR...', 'info');
+    updateCompileStatus('idle', 'Compiling...');
+
+    try {
+        const response = await fetch(`${BACKEND_URL}/api/compile`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ source })
+        });
+
+        const result = await response.json();
+
+        if (result.success) {
+            log(`✓ Compiled ${result.ir.length} actions`, 'success');
+
+            if (result.warnings.length > 0) {
+                result.warnings.forEach(w => {
+                    log(`  Warning (line ${w.line}): ${w.message}`, 'warning');
+                });
+            }
+
+            state.currentIR = result.ir;
+            displayIR(result.ir);
+            updateCompileStatus('success', `${result.ir.length} actions ready`);
+            return result.ir;
+        } else {
+            log('✗ Compilation failed', 'error');
+            result.errors.forEach(e => {
+                log(`  Error (line ${e.line}): ${e.message}`, 'error');
+            });
+            updateCompileStatus('error', 'Compilation failed');
+            return null;
+        }
+    } catch (error) {
+        log(`Backend error: ${error.message}`, 'error');
+        updateCompileStatus('error', 'Backend error');
+        return null;
+    }
+}
+
+// Display IR in the UI
+function displayIR(ir) {
+    if (!ir || ir.length === 0) {
+        elements.irDisplay.innerHTML = '<div style="color: #999; text-align: center; padding: 20px;">No actions</div>';
+        return;
+    }
+
+    const html = ir.map((action, idx) => {
+        let details = '';
+
+        if (action.type === 'action') {
+            details = `Duration: ${action.duration}s`;
+            if (action.head_pose) details += ', Head movement';
+            if (action.antennas) details += `, Antennas: [${action.antennas.map(a => a.toFixed(2)).join(', ')}]`;
+            if (action.body_yaw !== null) details += `, Body yaw: ${action.body_yaw.toFixed(2)}`;
+        } else if (action.type === 'wait') {
+            details = `Wait ${action.duration}s`;
+        } else if (action.type === 'picture') {
+            details = 'Take picture';
+        } else if (action.type === 'sound') {
+            details = `Play "${action.sound_name}"`;
+            if (action.blocking) details += ' (blocking)';
+            if (action.loop) details += ' (loop)';
+        }
+
+        return `
+            <div class="ir-action">
+                <div class="ir-action-type">${idx + 1}. ${action.type.toUpperCase()}</div>
+                <div class="ir-action-details">${details}</div>
+            </div>
+        `;
+    }).join('');
+
+    elements.irDisplay.innerHTML = html;
+}
+
+// Execute compiled script on robot
+async function executeScript() {
+    if (!state.robotConnected) {
+        log('Robot not connected!', 'error');
+        return;
+    }
+
+    if (state.isExecuting) {
+        log('Already executing a script', 'warning');
+        return;
+    }
+
+    // Always compile the current editor content before executing
+    const ir = await compileScript();
+    if (!ir) {
+        log('Cannot execute - compilation failed', 'error');
+        return;
+    }
+
+    // Execute IR actions sequentially
+    state.isExecuting = true;
+    elements.executeBtn.disabled = true;
+    clearExecutionInfo();
+    logExecution('Starting execution...', 'info');
+
+    try {
+        for (let i = 0; i < ir.length; i++) {
+            const action = ir[i];
+            logExecution(`Action ${i + 1}/${ir.length}: ${action.type}`, 'info');
+
+            if (action.type === 'action') {
+                await executeIRAction(action);
+            } else if (action.type === 'wait') {
+                await sleep(action.duration * 1000);
+            } else if (action.type === 'picture') {
+                logExecution('Picture action skipped (not implemented)', 'warning');
+            } else if (action.type === 'sound') {
+                logExecution('Sound action skipped (not implemented)', 'warning');
+            }
+        }
+
+        logExecution('✓ Execution complete!', 'success');
+    } catch (error) {
+        logExecution(`✗ Execution error: ${error.message}`, 'error');
+    } finally {
+        state.isExecuting = false;
+        if (state.robotConnected) {
+            elements.executeBtn.disabled = false;
+        }
+    }
+}
+
+// Extract euler angles (roll, pitch, yaw) from 3x3 rotation matrix
+// Uses XYZ euler convention to match scipy's R.from_matrix().as_euler("xyz")
+function matrixToEulerXYZ(rotMatrix) {
+    // Extract 3x3 rotation matrix from 4x4 pose matrix if needed
+    const R = rotMatrix;
+
+    // For XYZ euler order: R = Rz(yaw) * Ry(pitch) * Rx(roll)
+    // pitch = asin(-R[2][0])
+    // roll = atan2(R[2][1], R[2][2])
+    // yaw = atan2(R[1][0], R[0][0])
+
+    let pitch = Math.asin(-R[2][0]);
+
+    // Check for gimbal lock
+    if (Math.abs(Math.cos(pitch)) > 1e-6) {
+        // Normal case
+        const roll = Math.atan2(R[2][1], R[2][2]);
+        const yaw = Math.atan2(R[1][0], R[0][0]);
+        return { roll, pitch, yaw };
+    } else {
+        // Gimbal lock case
+        const roll = Math.atan2(-R[0][1], R[1][1]);
+        const yaw = 0;
+        return { roll, pitch, yaw };
+    }
+}
+
+// Execute a single IR action (send to robot)
+async function executeIRAction(action) {
+    if (!state.robotWs || state.robotWs.readyState !== WebSocket.OPEN) {
+        throw new Error('Robot WebSocket not connected');
+    }
+
+    const message = {};
+
+    if (action.head_pose) {
+        // Extract translation from 4x4 matrix
+        const x = action.head_pose[0][3];
+        const y = action.head_pose[1][3];
+        const z = action.head_pose[2][3];
+
+        // Extract rotation (euler angles) from 3x3 rotation matrix portion
+        const euler = matrixToEulerXYZ(action.head_pose);
+
+        message.target_head_pose = {
+            x: x,
+            y: y,
+            z: z,
+            roll: euler.roll,
+            pitch: euler.pitch,
+            yaw: euler.yaw
+        };
+    }
+
+    if (action.antennas) {
+        message.target_antennas = action.antennas;
+    }
+
+    if (action.body_yaw !== null) {
+        message.target_body_yaw = action.body_yaw;
+    }
+
+    // Send to robot
+    state.robotWs.send(JSON.stringify(message));
+
+    // Wait for the action duration
+    await sleep(action.duration * 1000);
+}
+
+// Log execution info
+function logExecution(message, type = 'info') {
+    const line = document.createElement('div');
+    line.className = `console-line ${type}`;
+    line.textContent = `[${new Date().toLocaleTimeString()}] ${message}`;
+    elements.executionInfo.appendChild(line);
+    elements.executionInfo.scrollTop = elements.executionInfo.scrollHeight;
+}
+
+// Clear execution info
+function clearExecutionInfo() {
+    elements.executionInfo.innerHTML = '';
+}
+
+// Sleep helper
+function sleep(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+}
+
+// Initialize application
+function init() {
+    console.log('Initializing RMScript Web Demo');
+
+    // Connect to robot
+    connectRobotWebSocket();
+
+    // Load default example
+    loadExample('basic');
+
+    console.log('RMScript Web Demo ready');
+}
+
+// Start when DOM is loaded
+if (document.readyState === 'loading') {
+    document.addEventListener('DOMContentLoaded', init);
+} else {
+    init();
+}

frontend/index.html

@@ -0,0 +1,331 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>RMScript Web Demo</title>
+    <style>
+        * {
+            margin: 0;
+            padding: 0;
+            box-sizing: border-box;
+        }
+
+        body {
+            font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Oxygen, Ubuntu, Cantarell, sans-serif;
+            background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+            min-height: 100vh;
+            padding: 20px;
+        }
+
+        .container {
+            max-width: 1400px;
+            margin: 0 auto;
+            background: white;
+            border-radius: 20px;
+            box-shadow: 0 20px 60px rgba(0, 0, 0, 0.3);
+            overflow: hidden;
+            display: grid;
+            grid-template-columns: 1fr 1fr;
+            gap: 0;
+        }
+
+        .panel {
+            padding: 30px;
+        }
+
+        .panel.editor-panel {
+            border-right: 1px solid #e0e0e0;
+        }
+
+        h1 {
+            color: #333;
+            margin-bottom: 10px;
+            font-size: 24px;
+        }
+
+        .subtitle {
+            color: #666;
+            margin-bottom: 20px;
+            font-size: 14px;
+        }
+
+        .status {
+            padding: 12px;
+            border-radius: 8px;
+            margin-bottom: 15px;
+            font-size: 14px;
+            display: flex;
+            justify-content: space-between;
+            align-items: center;
+        }
+
+        .status.idle {
+            background: #f5f5f5;
+            color: #666;
+        }
+
+        .status.success {
+            background: #d4edda;
+            color: #155724;
+        }
+
+        .status.error {
+            background: #f8d7da;
+            color: #721c24;
+        }
+
+        .status.connected {
+            background: #d4edda;
+            color: #155724;
+        }
+
+        .status.disconnected {
+            background: #f8d7da;
+            color: #721c24;
+        }
+
+        .status-dot {
+            width: 10px;
+            height: 10px;
+            border-radius: 50%;
+            margin-right: 8px;
+            display: inline-block;
+        }
+
+        .status-dot.green {
+            background: #28a745;
+            box-shadow: 0 0 10px #28a745;
+        }
+
+        .status-dot.red {
+            background: #dc3545;
+        }
+
+        .status-dot.gray {
+            background: #999;
+        }
+
+        .editor {
+            width: 100%;
+            min-height: 400px;
+            padding: 15px;
+            font-family: 'Monaco', 'Menlo', 'Consolas', monospace;
+            font-size: 14px;
+            border: 2px solid #e0e0e0;
+            border-radius: 8px;
+            resize: vertical;
+            margin-bottom: 15px;
+            line-height: 1.5;
+        }
+
+        .editor:focus {
+            outline: none;
+            border-color: #667eea;
+        }
+
+        .button-group {
+            display: flex;
+            gap: 10px;
+            margin-bottom: 20px;
+        }
+
+        button {
+            background: #667eea;
+            color: white;
+            border: none;
+            padding: 12px 24px;
+            border-radius: 8px;
+            font-size: 14px;
+            font-weight: 600;
+            cursor: pointer;
+            transition: all 0.2s;
+            flex: 1;
+        }
+
+        button:hover:not(:disabled) {
+            background: #5568d3;
+            transform: translateY(-2px);
+            box-shadow: 0 4px 12px rgba(102, 126, 234, 0.4);
+        }
+
+        button:active:not(:disabled) {
+            transform: translateY(0);
+        }
+
+        button:disabled {
+            opacity: 0.5;
+            cursor: not-allowed;
+        }
+
+        button.secondary {
+            background: #6c757d;
+        }
+
+        button.secondary:hover:not(:disabled) {
+            background: #5a6268;
+        }
+
+        button.danger {
+            background: #dc3545;
+        }
+
+        button.danger:hover:not(:disabled) {
+            background: #c82333;
+        }
+
+        .console {
+            background: #1e1e1e;
+            color: #d4d4d4;
+            padding: 15px;
+            border-radius: 8px;
+            font-family: 'Monaco', 'Menlo', 'Consolas', monospace;
+            font-size: 12px;
+            max-height: 300px;
+            overflow-y: auto;
+            line-height: 1.6;
+        }
+
+        .console-line {
+            margin-bottom: 4px;
+        }
+
+        .console-line.error {
+            color: #f48771;
+        }
+
+        .console-line.warning {
+            color: #dcdcaa;
+        }
+
+        .console-line.success {
+            color: #4ec9b0;
+        }
+
+        .console-line.info {
+            color: #9cdcfe;
+        }
+
+        .section-title {
+            font-size: 16px;
+            font-weight: 600;
+            color: #333;
+            margin-bottom: 10px;
+            text-transform: uppercase;
+            letter-spacing: 0.5px;
+        }
+
+        .example-buttons {
+            display: flex;
+            gap: 8px;
+            margin-bottom: 15px;
+            flex-wrap: wrap;
+        }
+
+        .example-buttons button {
+            flex: 0 1 auto;
+            padding: 8px 16px;
+            font-size: 12px;
+        }
+
+        .ir-display {
+            background: #f8f9fa;
+            padding: 15px;
+            border-radius: 8px;
+            max-height: 300px;
+            overflow-y: auto;
+            font-size: 13px;
+            margin-top: 15px;
+        }
+
+        .ir-action {
+            background: white;
+            padding: 10px;
+            margin-bottom: 8px;
+            border-radius: 4px;
+            border-left: 4px solid #667eea;
+        }
+
+        .ir-action-type {
+            font-weight: 600;
+            color: #667eea;
+            margin-bottom: 4px;
+        }
+
+        .ir-action-details {
+            font-size: 12px;
+            color: #666;
+            font-family: 'Monaco', 'Menlo', 'Consolas', monospace;
+        }
+    </style>
+</head>
+<body>
+    <div class="container">
+        <!-- Left Panel: Editor -->
+        <div class="panel editor-panel">
+            <h1>🤖 RMScript Editor</h1>
+            <p class="subtitle">Write and test your rmscript code</p>
+
+            <div id="compileStatus" class="status idle">
+                <span><span class="status-dot gray"></span>Ready</span>
+            </div>
+
+            <div class="section-title">Examples</div>
+            <div class="example-buttons">
+                <button class="secondary" onclick="loadExample('basic')">Basic</button>
+                <button class="secondary" onclick="loadExample('complex')">Complex</button>
+                <button class="secondary" onclick="loadExample('repeat')">Repeat</button>
+                <button class="secondary" onclick="clearEditor()">Clear</button>
+            </div>
+
+            <textarea id="editor" class="editor" placeholder="DESCRIPTION My robot script
+look left
+wait 1s
+look right"></textarea>
+
+            <div class="button-group">
+                <button onclick="verifyScript()">✓ Verify</button>
+                <button id="executeBtn" onclick="executeScript()" disabled>▶ Execute</button>
+            </div>
+
+            <div class="section-title">Console</div>
+            <div id="console" class="console">
+                <div class="console-line info">Ready. Write some rmscript and click Verify!</div>
+            </div>
+        </div>
+
+        <!-- Right Panel: Robot Control -->
+        <div class="panel">
+            <h1>🔗 Robot Connection</h1>
+            <p class="subtitle">Connect to Reachy Mini on localhost:8000</p>
+
+            <div id="robotStatus" class="status disconnected">
+                <span><span class="status-dot red"></span>Disconnected</span>
+            </div>
+
+            <div class="section-title">Compiled IR</div>
+            <div id="irDisplay" class="ir-display">
+                <div style="color: #999; text-align: center; padding: 20px;">
+                    No IR yet. Verify a script first!
+                </div>
+            </div>
+
+            <div class="section-title" style="margin-top: 20px;">Execution Info</div>
+            <div id="executionInfo" class="console" style="max-height: 150px;">
+                <div class="console-line info">Ready to execute when robot is connected</div>
+            </div>
+        </div>
+    </div>
+
+    <!-- Load app.js with path that works both locally (file://) and on server -->
+    <script>
+        // Auto-detect correct path for app.js
+        const scriptSrc = window.location.protocol === 'file:'
+            ? './app.js'  // Local file access
+            : '/static/app.js';  // Served from web server
+        const script = document.createElement('script');
+        script.src = scriptSrc;
+        document.head.appendChild(script);
+    </script>
+</body>
+</html>

reachy_mini/.gitattributes

@@ -0,0 +1,15 @@
+*.png filter=lfs diff=lfs merge=lfs -text
+*.jpg filter=lfs diff=lfs merge=lfs -text
+*.jpeg filter=lfs diff=lfs merge=lfs -text
+*.gif filter=lfs diff=lfs merge=lfs -text
+*.mp4 filter=lfs diff=lfs merge=lfs -text
+*.avi filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.tar.gz filter=lfs diff=lfs merge=lfs -text
+*.pdf filter=lfs diff=lfs merge=lfs -text
+*.obj filter=lfs diff=lfs merge=lfs -text
+*.stl filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.svg filter=lfs diff=lfs merge=lfs -text

reachy_mini/.github/workflows/lint.yml

@@ -0,0 +1,27 @@
+name: Linters
+on: [ push, pull_request ]
+jobs:
+  ruff:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: astral-sh/ruff-action@v3
+        with:
+          version: "0.12.0"
+
+  mypy:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - name: Set up Python 3.10
+        uses: actions/setup-python@v5
+        with:
+          python-version: "3.10"
+          cache: 'pip' # caching pip dependencies
+      - name: Install dependencies
+        run: |
+          python -m pip install --upgrade pip
+          pip install .[dev]
+      - name : Lint with mypy
+        run : |
+          mypy --install-types --non-interactive

reachy_mini/.github/workflows/pytest.yml

@@ -0,0 +1,28 @@
+name: Pytest
+on: [pull_request]
+jobs:
+  pytest:
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        os: [ubuntu-latest, macos-latest]
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          lfs: "true"
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.10"
+          cache: "pip"
+      - name: Install system dependencies (Ubuntu)
+        if: matrix.os == 'ubuntu-latest'
+        run: sudo apt-get update && sudo apt-get install -y libportaudio2
+      - name: Install dependencies
+        run: |
+          python -m pip install --upgrade pip
+          pip install .[dev]
+      - name: Run tests
+        run: |
+          pytest -vv -m 'not audio and not video and not audio_gstreamer and not video_gstreamer and not wireless and not wireless_gstreamer' --tb=short
+        env:
+          MUJOCO_GL: disable

reachy_mini/.github/workflows/wheels.yml

@@ -0,0 +1,26 @@
+name: Publish
+
+on:
+  release:
+    types:
+      - created
+
+jobs:
+  publish:
+    runs-on: ubuntu-latest
+    permissions:
+      id-token: write
+    steps:
+      - uses: actions/checkout@v5
+        with:
+          lfs: true
+      - name: Set up Python
+        uses: actions/setup-python@v6
+        with:
+          python-version: "3.10"
+      - name: Install build dependencies
+        run: pip install build
+      - name: Build distribution
+        run: python -m build
+      - name: Publish
+        uses: pypa/[email protected]

reachy_mini/.github/workflows/wheels.yml.bak

@@ -0,0 +1,181 @@
+name: Build and Release Wheels
+
+on:
+  push:
+    tags:
+      - "*"
+  workflow_dispatch:
+
+jobs:
+  linux:
+    runs-on: ${{ matrix.platform.runner }}
+    if: ${{ startsWith(github.ref, 'refs/tags/') || github.event_name == 'workflow_dispatch' }}
+    strategy:
+      matrix:
+        platform:
+          - runner: ubuntu-22.04
+            target: x86_64
+          - runner: ubuntu-22.04
+            target: x86
+          - runner: ubuntu-22.04
+            target: aarch64
+          - runner: ubuntu-22.04
+            target: armv7
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: |
+            3.8
+            3.9
+            3.10
+            3.11
+            3.12
+            3.13
+      - name: Build wheels
+        run: |
+          pip install build
+          python -m build --wheel --outdir dist
+      - name: Upload wheels
+        uses: actions/upload-artifact@v4
+        with:
+          name: wheels-linux-${{ matrix.platform.target }}
+          path: dist/*.whl
+
+  musllinux:
+    runs-on: ${{ matrix.platform.runner }}
+    if: ${{ startsWith(github.ref, 'refs/tags/') || github.event_name == 'workflow_dispatch' }}
+    strategy:
+      matrix:
+        platform:
+          - runner: ubuntu-22.04
+            target: x86_64
+          - runner: ubuntu-22.04
+            target: x86
+          - runner: ubuntu-22.04
+            target: aarch64
+          - runner: ubuntu-22.04
+            target: armv7
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: |
+            3.8
+            3.9
+            3.10
+            3.11
+            3.12
+            3.13
+      - name: Build wheels
+        run: |
+          pip install build
+          python -m build --wheel --outdir dist
+      - name: Upload wheels
+        uses: actions/upload-artifact@v4
+        with:
+          name: wheels-musllinux-${{ matrix.platform.target }}
+          path: dist/*.whl
+
+  windows:
+    runs-on: ${{ matrix.platform.runner }}
+    if: ${{ startsWith(github.ref, 'refs/tags/') || github.event_name == 'workflow_dispatch' }}
+    strategy:
+      matrix:
+        platform:
+          - runner: windows-latest
+            target: x64
+          - runner: windows-latest
+            target: x86
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: |
+            3.8
+            3.9
+            3.10
+            3.11
+            3.12
+            3.13
+          architecture: ${{ matrix.platform.target }}
+      - name: Build wheels
+        run: |
+          pip install build
+          python -m build --wheel --outdir dist
+      - name: Upload wheels
+        uses: actions/upload-artifact@v4
+        with:
+          name: wheels-windows-${{ matrix.platform.target }}
+          path: dist/*.whl
+
+  macos:
+    runs-on: ${{ matrix.platform.runner }}
+    if: ${{ startsWith(github.ref, 'refs/tags/') || github.event_name == 'workflow_dispatch' }}
+    strategy:
+      matrix:
+        platform:
+          - runner: macos-13
+            target: x86_64
+          - runner: macos-14
+            target: aarch64
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: |
+            3.8
+            3.9
+            3.10
+            3.11
+            3.12
+            3.13
+      - name: Build wheels
+        run: |
+          pip install build
+          python -m build --wheel --outdir dist
+      - name: Upload wheels
+        uses: actions/upload-artifact@v4
+        with:
+          name: wheels-macos-${{ matrix.platform.target }}
+          path: dist/*.whl
+
+  sdist:
+    runs-on: ubuntu-latest
+    if: ${{ startsWith(github.ref, 'refs/tags/') || github.event_name == 'workflow_dispatch' }}
+    steps:
+      - uses: actions/checkout@v4
+      - name: Build sdist
+        run: |
+          pip install build
+          python -m build --sdist --outdir dist
+      - name: Upload sdist
+        uses: actions/upload-artifact@v4
+        with:
+          name: wheels-sdist
+          path: dist/*.tar.gz
+
+  release:
+    name: Release
+    runs-on: ubuntu-latest
+    if: ${{ startsWith(github.ref, 'refs/tags/') || github.event_name == 'workflow_dispatch' }}
+    needs: [linux, musllinux, windows, macos, sdist]
+    permissions:
+      id-token: write
+      contents: write
+      attestations: write
+    steps:
+      - uses: actions/download-artifact@v4
+        with:
+          pattern: wheels-*
+          merge-multiple: true
+          path: dist
+      - name: Generate artifact attestation
+        uses: actions/attest-build-provenance@v1
+        with:
+          subject-path: 'dist/*'
+      - name: Publish to PyPI
+        if: ${{ startsWith(github.ref, 'refs/tags/') }}
+        uses: pypa/gh-action-pypi-publish@release/v1
+        with:
+          packages-dir: dist/

reachy_mini/.gitignore

@@ -0,0 +1,256 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[codz]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#   Usually these files are written by a python script from a template
+#   before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py.cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+# Pipfile.lock
+
+# UV
+#   Similar to Pipfile.lock, it is generally recommended to include uv.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+# uv.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+# poetry.lock
+# poetry.toml
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#   pdm recommends including project-wide configuration in pdm.toml, but excluding .pdm-python.
+#   https://pdm-project.org/en/latest/usage/project/#working-with-version-control
+# pdm.lock
+# pdm.toml
+.pdm-python
+.pdm-build/
+
+# pixi
+#   Similar to Pipfile.lock, it is generally recommended to include pixi.lock in version control.
+# pixi.lock
+#   Pixi creates a virtual environment in the .pixi directory, just like venv module creates one
+#   in the .venv directory. It is recommended not to include this directory in version control.
+.pixi
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# Redis
+*.rdb
+*.aof
+*.pid
+
+# RabbitMQ
+mnesia/
+rabbitmq/
+rabbitmq-data/
+
+# ActiveMQ
+activemq-data/
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.envrc
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+.idea/**/workspace.xml
+.idea/**/tasks.xml
+.idea/**/usage.statistics.xml
+.idea/**/dictionaries
+.idea/**/shelf
+.idea/**/dataSources/
+.idea/**/dataSources.ids
+.idea/**/dataSources.local.xml
+.idea/**/sqlDataSources.xml
+.idea/**/dynamic.xml
+.idea/**/uiDesigner.xml
+.idea/**/dbnavigator.xml
+.idea/**/contentModel.xml
+
+# Abstra
+#   Abstra is an AI-powered process automation framework.
+#   Ignore directories containing user credentials, local state, and settings.
+#   Learn more at https://abstra.io/docs
+.abstra/
+
+# Visual Studio Code
+.vscode/*
+!.vscode/settings.json
+!.vscode/tasks.json
+!.vscode/launch.json
+!.vscode/extensions.json
+!.vscode/*.code-snippets
+!*.code-workspace
+
+# Ruff stuff:
+.ruff_cache/
+
+# PyPI configuration file
+.pypirc
+
+# Marimo
+marimo/_static/
+marimo/_lsp/
+__marimo__/
+
+# Streamlit
+.streamlit/secrets.toml
+
+# General for macOS
+.DS_Store
+__MACOSX/
+.AppleDouble
+.LSOverride
+Icon[]
+
+# General for Linux
+*~
+.fuse_hidden*
+.directory
+.Trash-*
+.nfs*
+nohup.out
+
+# General for Windows
+Thumbs.db
+Thumbs.db:encryptable
+ehthumbs.db
+ehthumbs_vista.db
+[Dd]esktop.ini
+*.stackdump
+$RECYCLE.BIN/
+*.lnk
+
+# Project specific ignores
+src/reachy_mini_dashboard/installed_apps/*
+examples/debug/measures/*
+.DS_Store

reachy_mini/.pre-commit-config.yaml

@@ -0,0 +1,10 @@
+repos:
+- repo: https://github.com/astral-sh/ruff-pre-commit
+  # Ruff version. Make sure it matches the version in .github/workflows/lint.yml.
+  rev: v0.12.0
+  hooks:
+    # Run the linter.
+    - id: ruff-check
+      args: ["--select", "I", "--select", "D", "--ignore", "D203", "--ignore", "D213"]
+    # Run the formatter.
+    - id: ruff-format

reachy_mini/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright 2025 Pollen Robotics
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

reachy_mini/MANIFEST.in

@@ -0,0 +1,3 @@
+recursive-include src/reachy_mini/assets *
+recursive-include src/reachy_mini/templates *
+recursive-include src/reachy_mini/descriptions *

reachy_mini/README.md

@@ -0,0 +1,246 @@
+# Reachy Mini
+
+> ⚠️ Reachy Mini is still in beta. Expect bugs, some of them we won't fix right away if they are not a priority.
+
+[Reachy Mini](https://www.pollen-robotics.com/reachy-mini/) is an expressive, open-source robot designed for human-robot interaction, creative coding, and AI experimentation. We made it to be affordable, easy to use, hackable and cute, so that you can focus on building cool AI applications!
+
+[![Reachy Mini Hello](/docs/assets/reachy_mini_hello.gif)](https://www.pollen-robotics.com/reachy-mini/)
+
+### Versions Lite & Wireless
+
+Reachy Mini's hardware comes in two flavors:
+- **Reachy Mini lite**: where the robot is directly connected to your computer via USB. And the code that controls the robot (the daemon) runs on your computer.
+- **Reachy Mini wireless**: where an Raspberry Pi is embedded in the robot, and the code that controls the robot (the daemon) runs on the Raspberry Pi. You can connect to it via Wi-Fi from your computer (see [Wireless Setup](./docs/wireless-version.md)).
+
+There is also a simulated version of Reachy Mini in [MuJoCo](https://mujoco.org) that you can use to prototype your applications before deploying them on the real robot. It behaves like the lite version where the daemon runs on your computer.
+
+## Assembly guide
+
+📖 Follow our step-by-step [Assembly Guide](https://huggingface.co/spaces/pollen-robotics/Reachy_Mini_Assembly_Guide).
+
+Most builders finish in about 3 hours, our current speed record is 43 minutes. The guide walks you through every step with clear visuals so you can assemble Reachy Mini confidently from start to finish. Enjoy the build!
+
+▶️ View the [Assembly Video](https://youtu.be/_r0cHySFbeY?si=6Mw4js8HSUs4cwoJ).
+
+## Software overview
+
+This repository provides everything you need to control Reachy Mini, both in simulation and on the real robot. It consists of two main parts:
+
+- **The 😈 Daemon 😈**: A background service that manages communication with the robot's motors and sensors, or with the simulation environment. It should be running before you can control the robot. It can run either for the simulation (MuJoCo) or for the real robot. 
+- **🐍 SDK & 🕸️ API** to control the robot's main features (head, antennas, camera, speakers, microphone, etc.) and connect with your AI experimentation. Depending on your preferences and needs, there is a [Python SDK](#using-the-python-sdk) and a [HTTP REST API](#using-the-rest-api).
+
+Using the [Python SDK](#using-the-python-sdk), making your robot move only require a few lines of code, as illustrated in the example below:
+
+```python
+from reachy_mini import ReachyMini
+from reachy_mini.utils import create_head_pose
+
+with ReachyMini() as reachy_mini:
+    # Move the head up (10mm on z-axis) and roll it 15 degrees
+    pose = create_head_pose(z=10, roll=15, degrees=True, mm=True)
+    reachy_mini.goto_target(head=pose, duration=2.0)
+
+    # Reset to default pose
+    pose = create_head_pose() 
+    reachy_mini.goto_target(head=pose, duration=2.0)
+```
+
+and using the [REST API](#using-the-rest-api), reading the current state of the robot:
+
+```bash
+curl 'http://localhost:8000/api/state/full'
+```
+
+Those two examples above assume that the daemon is already running (either in simulation or on the real robot) locally.
+
+## Installation of the daemon and Python SDK
+
+As mentioned above, before being able to use the robot, you need to run the daemon that will handle the communication with the motors.
+
+We support and test on Linux and macOS. It's also working on Windows, but it is less tested at the moment. Do not hesitate to open an issue if you encounter any problem. 
+
+The daemon is built in Python, so you need to have Python installed on your computer (versions from 3.10 to 3.13 are supported). We recommend using a virtual environment to avoid dependency conflicts with your other Python projects.
+
+You can install Reachy Mini from the source code or from PyPI.
+
+First, make sure `git-lfs` is installed on your system:
+
+- On Linux: `sudo apt install git-lfs`
+- On macOS: `brew install git-lfs`
+- On Windows: [Follow the instructions here](https://docs.github.com/en/repositories/working-with-files/managing-large-files/installing-git-large-file-storage?platform=windows)
+
+From PyPI, you can install the package with:
+
+```bash
+pip install reachy-mini
+```
+
+From the source code, you can install the package with:
+
+```bash
+git clone https://github.com/pollen-robotics/reachy_mini
+pip install -e ./reachy_mini
+```
+
+*Note that uv users can directly run the daemon with:*
+```bash
+uv run reachy-mini-daemon
+```
+
+The same package provides both the daemon and the Python SDK.
+
+
+## Run the reachy mini daemon
+
+Before being able to use the robot, you need to run the daemon that will handle the communication with the motors. This daemon can run either in simulation (MuJoCo) or on the real robot.
+
+```bash
+reachy-mini-daemon
+```
+
+or run it via the Python module:
+
+```bash
+python -m reachy_mini.daemon.app.main
+```
+
+Additional argument for both simulation and real robot:
+
+```bash
+--localhost-only: (default behavior). The server will only accept connections from localhost.
+```
+
+or
+
+```bash
+--no-localhost-only: If set, the server will accept connections from any connection on the local network.
+```
+
+### In simulation ([MuJoCo](https://mujoco.org))
+
+You first have to install the optional dependency `mujoco`.
+
+```bash
+pip install reachy-mini[mujoco]
+```
+
+Then run the daemon with the `--sim` argument.
+
+```bash
+reachy-mini-daemon --sim
+```
+
+Additional arguments:
+
+```bash
+--scene <empty|minimal> : (Default empty). Choose between a basic empty scene, or a scene with a table and some objects.
+```
+
+<img src="https://www.pollen-robotics.com/wp-content/uploads/2025/06/Reachy_mini_simulation.gif" width="250" alt="Reachy Mini in MuJoCo">
+
+
+*Note: On OSX in order to run mujoco, you need to use mjpython (see [here](https://mujoco.readthedocs.io/en/stable/python.html#passive-viewer)). So, you should run the daemon with:*
+
+```bash
+ mjpython -m reachy_mini.daemon.app.main --sim
+ ```
+
+### For the lite version (connected via USB)
+
+It should automatically detect the serial port of the robot. If it does not, you can specify it manually with the `-p` option:
+
+```bash
+reachy-mini-daemon -p <serial_port>
+```
+
+### Usage
+
+For more information about the daemon and its options, you can run:
+
+```bash
+reachy-mini-daemon --help
+```
+
+### Dashboard
+
+You can access a simple dashboard to monitor the robot's status at [http://localhost:8000/](http://localhost:8000/) when the daemon is running. This lets you turn your robot on and off, run some basic movements, and browse spaces for Reachy Mini!
+
+![Reachy Mini Dashboard](docs/assets/dashboard.png)
+
+## Run the demo & awesome apps
+
+Conversational demo for the Reachy Mini robot combining LLM realtime APIs, vision pipelines, and choreographed motion libraries: [reachy_mini_conversation_demo](https://github.com/pollen-robotics/reachy_mini_conversation_demo).
+
+You can find more awesome apps and demos for Reachy Mini on [Hugging Face spaces](https://huggingface.co/spaces?q=reachy_mini)!
+
+## Using the Python SDK
+
+The API is designed to be simple and intuitive. You can control the robot's features such as the head, antennas, camera, speakers, and microphone. For instance, to move the head of the robot, you can use the `goto_target` method as shown in the example below:
+
+```python
+from reachy_mini import ReachyMini
+from reachy_mini.utils import create_head_pose
+
+with ReachyMini() as reachy_mini:
+    # Move the head up (10mm on z-axis) and roll it 15 degrees
+    pose = create_head_pose(z=10, roll=15, degrees=True, mm=True)
+    reachy_mini.goto_target(head=pose, duration=2.0)
+
+    # Reset to default pose
+    pose = create_head_pose() 
+    reachy_mini.goto_target(head=pose, duration=2.0)
+```
+
+For a full description of the SDK, please refer to the [Python SDK documentation](./docs/python-sdk.md).
+
+## Using the REST API
+
+The daemon also provides a REST API via [fastapi](https://fastapi.tiangolo.com/) that you can use to control the robot and get its state. The API is accessible via HTTP and WebSocket.
+
+By default, the API server runs on `http://localhost:8000`. The API is documented using OpenAPI, and you can access the documentation at `http://localhost:8000/docs` when the daemon is running.
+
+More information about the API can be found in the [HTTP API documentation](./docs/rest-api.md).
+
+## Open source & contribution
+
+This project is actively developed and maintained by the [Pollen Robotics team](https://www.pollen-robotics.com) and the [Hugging Face team](https://huggingface.co/). 
+
+We welcome contributions from the community! If you want to report a bug or request a feature, please open an issue on GitHub. If you want to contribute code, please fork the repository and submit a pull request.
+
+### 3D models
+
+TODO
+
+### Contributing
+
+Development tools are available in the optional dependencies.
+
+```bash
+pip install -e .[dev]
+pre-commit install
+```
+
+Your files will be checked before any commit. Checks may also be manually run with
+
+```bash
+pre-commit run --all-files
+```
+
+Checks are performed by Ruff. You may want to [configure your IDE to support it](https://docs.astral.sh/ruff/editors/setup/).
+
+## Troubleshooting
+
+see [dedicated section](docs/troubleshooting.md)
+
+## License
+
+This project is licensed under the Apache 2.0 License - see the [LICENSE](LICENSE) file for details.
+
+The robot design files are licensed under the [TODO](TODO) license.
+
+### Simulation model used
+
+- https://polyhaven.com/a/food_apple_01
+- https://polyhaven.com/a/croissant
+- https://polyhaven.com/a/wooden_table_02
+- https://polyhaven.com/a/rubber_duck_toy

reachy_mini/pyproject.toml

@@ -0,0 +1,111 @@
+[build-system]
+requires = ["setuptools"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "reachy_mini"
+version = "1.1.1"
+authors = [{ name = "Pollen Robotics", email = "[email protected]" }]
+description = ""
+readme = "README.md"
+requires-python = ">=3.10"
+dependencies = [
+    "numpy>=2.2.5",
+    "scipy>=1.15.3, <2.0.0",
+    "reachy_mini_motor_controller>=1.4.2",
+    "eclipse-zenoh>=1.4.0",
+    "opencv-python<=5.0",
+    "cv2_enumerate_cameras>=1.2.1",
+    "psutil",
+    "jinja2",
+    "uvicorn[standard]",
+    "fastapi",
+    "pyserial",
+    "huggingface-hub==0.34.4",
+    "sounddevice==0.5.1",
+    "soundfile==0.13.1",
+    "reachy-mini-rust-kinematics>=1.0.2",
+    "asgiref",
+    "aiohttp",
+    "log-throttling==0.0.3",
+    "pyusb>=1.2.1",
+    "libusb_package>=1.0.26.3",
+    "pip>=25",
+]
+
+
+[project.optional-dependencies]
+dev = [
+    "pytest",
+    "pytest-asyncio",
+    "ruff==0.12.0",
+    "onshape-to-robot==1.7.6",
+    "mujoco==3.3.0",
+    "placo==0.9.14",
+    "pre-commit",
+    "mypy==1.18.2",
+    "rustypot>=1.4.0",
+    "types-requests",
+    "rerun-sdk>=0.27.2",
+    "urdf-parser-py==0.0.4",
+]
+examples = ["pynput"]
+mujoco = ["mujoco==3.3.0"]
+nn_kinematics = ["onnxruntime==1.22.1"]
+placo_kinematics = ["placo==0.9.14"]
+gstreamer = ["PyGObject>=3.42.2,<=3.46.0", "gst-signalling>=1.1.2"]
+rerun = ["rerun-sdk>=0.27.2", "urdf-parser-py==0.0.4"]
+wireless-version = [
+    "semver>=3,<4",
+    "nmcli>=1.5",
+    "pollen_BMI088_imu_library",
+    "gpiozero>=2.0.0",
+    "lgpio>=0.2.2.0",
+]
+
+[project.scripts]
+reachy-mini-daemon = "reachy_mini.daemon.app.main:main"
+reachy-mini-apps-helper = "reachy_mini.apps.app:main"
+
+[tool.setuptools]
+package-dir = { "" = "src" }
+include-package-data = true
+
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+
+[tool.setuptools.package-data]
+reachy_mini = ["**/*"] # Inclut tous les fichiers non .py
+
+[tool.ruff]
+exclude = [
+    "src/reachy_mini/__init__.py",
+    "build/*",
+    "conftest.py",
+    "src/reachy_mini_dashboard/*",
+    "tests/*",
+]
+lint.extend-select = ["I", "D"]
+lint.ignore = [
+    "D203", # Incompatible with D211
+    "D213", # Incompatible with D212
+]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+markers = [
+    "audio: mark test as requiring audio hardware",
+    "audio_gstreamer: mark test as requiring GStreamer for audio",
+    "video: mark test as requiring video hardware",
+    "video_gstreamer: mark test as requiring GStreamer for video",
+    "wireless: mark test as requiring wireless Reachy Mini",
+    "wireless_gstreamer: mark test as requiring GStreamer for wireless Reachy Mini",
+]
+
+[tool.mypy]
+python_version = "3.10"
+files = ["src/"]
+ignore_missing_imports = true
+strict = true

reachy_mini/src/reachy_mini/__init__.py

@@ -0,0 +1,4 @@
+"""Reachy Mini SDK."""
+
+from reachy_mini.apps.app import ReachyMiniApp  # noqa: F401
+from reachy_mini.reachy_mini import ReachyMini  # noqa: F401

reachy_mini/src/reachy_mini/apps/__init__.py

@@ -0,0 +1,25 @@
+"""Metadata about apps."""
+
+from dataclasses import dataclass, field
+from enum import Enum
+from typing import Any, Dict
+
+
+class SourceKind(str, Enum):
+    """Kinds of app source."""
+
+    HF_SPACE = "hf_space"
+    DASHBOARD_SELECTION = "dashboard_selection"
+    LOCAL = "local"
+    INSTALLED = "installed"
+
+
+@dataclass
+class AppInfo:
+    """Metadata about an app."""
+
+    name: str
+    source_kind: SourceKind
+    description: str = ""
+    url: str | None = None
+    extra: Dict[str, Any] = field(default_factory=dict)

reachy_mini/src/reachy_mini/apps/app.py

@@ -0,0 +1,169 @@
+"""Reachy Mini Application Base Class.
+
+This module provides a base class for creating Reachy Mini applications.
+It includes methods for running the application, stopping it gracefully,
+and creating a new app project with a specified name and path.
+
+It uses Jinja2 templates to generate the necessary files for the app project.
+"""
+
+import os
+import threading
+import traceback
+from abc import ABC, abstractmethod
+from pathlib import Path
+from typing import Any, Dict
+
+from jinja2 import Environment, FileSystemLoader
+
+from reachy_mini.reachy_mini import ReachyMini
+
+
+class ReachyMiniApp(ABC):
+    """Base class for Reachy Mini applications."""
+
+    custom_app_url: str | None = None
+
+    def __init__(self) -> None:
+        """Initialize the Reachy Mini app."""
+        self.stop_event = threading.Event()
+        self.error: str = ""
+
+    def wrapped_run(self, *args: Any, **kwargs: Any) -> None:
+        """Wrap the run method with Reachy Mini context management."""
+        try:
+            with ReachyMini(*args, **kwargs) as reachy_mini:
+                self.run(reachy_mini, self.stop_event)
+        except Exception:
+            self.error = traceback.format_exc()
+            raise
+
+    @abstractmethod
+    def run(self, reachy_mini: ReachyMini, stop_event: threading.Event) -> None:
+        """Run the main logic of the app.
+
+        Args:
+            reachy_mini (ReachyMini): The Reachy Mini instance to interact with.
+            stop_event (threading.Event): An event that can be set to stop the app gracefully.
+
+        """
+        pass
+
+    def stop(self) -> None:
+        """Stop the app gracefully."""
+        self.stop_event.set()
+        print("App is stopping...")
+
+
+def make_app_project(app_name: str, path: Path) -> None:
+    """Create a new Reachy Mini app project with the given name at the specified path.
+
+    Args:
+        app_name (str): The name of the app to create.
+        path (Path): The directory where the app project will be created.
+
+    """
+    TEMPLATE_DIR = Path(__file__).parent / "templates"
+    env = Environment(loader=FileSystemLoader(TEMPLATE_DIR))
+
+    def render_template(filename: str, context: Dict[str, str]) -> str:
+        template = env.get_template(filename)
+        return template.render(context)
+
+    base_path = Path(path).resolve() / app_name
+    if base_path.exists():
+        print(f"❌ Folder {base_path} already exists.")
+        return
+
+    module_name = app_name.replace("-", "_")
+    class_name = "".join(word.capitalize() for word in module_name.split("_"))
+    class_name_display = " ".join(word.capitalize() for word in module_name.split("_"))
+
+    base_path.mkdir()
+    (base_path / module_name).mkdir()
+
+    # Generate files
+    context = {
+        "app_name": app_name,
+        "package_name": app_name,
+        "module_name": module_name,
+        "class_name": class_name,
+        "class_name_display": class_name_display,
+    }
+
+    (base_path / module_name / "__init__.py").touch()
+    (base_path / module_name / "main.py").write_text(
+        render_template("main.py.j2", context)
+    )
+    (base_path / "pyproject.toml").write_text(
+        render_template("pyproject.toml.j2", context)
+    )
+    (base_path / "README.md").write_text(render_template("README.md.j2", context))
+
+    (base_path / "index.html").write_text(render_template("index.html.j2", context))
+    (base_path / "style.css").write_text(render_template("style.css.j2", context))
+
+    print(f"✅ Created app in {base_path}/")
+
+
+def publish_app(app_path: str, hf_space_url: Path) -> None:
+    """Publish the app to the Reachy Mini app store.
+
+    Args:
+        app_path (str): Local path to the app to publish.
+        hf_space_url (Path): Url to the space on Hugging Face.
+
+    """
+    # Placeholder for publishing logic
+    assert os.path.exists(app_path), f"App path {app_path} does not exist."
+    print(f"Publishing app from {app_path} to {hf_space_url}...")
+    os.system(
+        f"cd {app_path} && git init && git remote add space {hf_space_url} && git add . && git commit -m 'Initial commit' && git push -f space main:main"
+    )
+    print("✅ App published successfully.")
+
+
+def main() -> None:
+    """Run the command line interface to create a new Reachy Mini app project."""
+    import argparse
+
+    parser = argparse.ArgumentParser(
+        description="Create a new Reachy Mini app project."
+    )
+    subparsers = parser.add_subparsers(
+        dest="command", help="Available commands", required=True
+    )
+
+    make_parser = subparsers.add_parser("make", help="Make a new app project")
+    make_parser.add_argument(
+        "--option", type=str, help="An option for the make command"
+    )
+    make_parser.add_argument("app_name", type=str, help="Name of the app to create.")
+    make_parser.add_argument(
+        "path",
+        type=Path,
+        default=Path.cwd(),
+        help="Path where the app project will be created.",
+    )
+
+    publish_parser = subparsers.add_parser(
+        "publish", help="Publish the app to the Reachy Mini app store"
+    )
+    publish_parser.add_argument(
+        "app_path", type=str, help="Local path to the app to publish."
+    )
+    publish_parser.add_argument(
+        "hf_space_url", type=Path, help="Url to the space on Hugging Face."
+    )
+
+    args = parser.parse_args()
+
+    if args.command == "make":
+        make_app_project(args.app_name, args.path)
+
+    elif args.command == "publish":
+        publish_app(args.app_path, args.hf_space_url)
+
+
+if __name__ == "__main__":
+    main()

reachy_mini/src/reachy_mini/apps/manager.py

@@ -0,0 +1,185 @@
+"""App management for Reachy Mini."""
+
+import asyncio
+import logging
+from dataclasses import dataclass
+from enum import Enum
+from importlib.metadata import entry_points
+from threading import Thread
+from typing import TYPE_CHECKING, Any, Optional
+
+from pydantic import BaseModel
+
+from . import AppInfo, SourceKind
+from .sources import hf_space, local_common_venv
+
+if TYPE_CHECKING:
+    from .app import ReachyMiniApp
+
+
+class AppState(str, Enum):
+    """Status of a running app."""
+
+    STARTING = "starting"
+    RUNNING = "running"
+    DONE = "done"
+    STOPPING = "stopping"
+    ERROR = "error"
+
+
+class AppStatus(BaseModel):
+    """Status of an app."""
+
+    info: AppInfo
+    state: AppState
+    error: str | None = None
+
+
+@dataclass
+class RunningApp:
+    """Information about a running app."""
+
+    app: "ReachyMiniApp"
+    thread: Thread
+    status: AppStatus
+
+
+class AppManager:
+    """Manager for Reachy Mini apps."""
+
+    def __init__(self) -> None:
+        """Initialize the AppManager."""
+        self.current_app = None  # type: RunningApp | None
+        self.logger = logging.getLogger("reachy_mini.apps.manager")
+
+    async def close(self) -> None:
+        """Clean up the AppManager, stopping any running app."""
+        if self.is_app_running():
+            await self.stop_current_app()
+
+    # App lifecycle management
+    # Only one app can be started at a time for now
+    def is_app_running(self) -> bool:
+        """Check if an app is currently running."""
+        return self.current_app is not None and self.current_app.status.state in (
+            AppState.STARTING,
+            AppState.RUNNING,
+            AppState.ERROR,
+        )
+
+    async def start_app(self, app_name: str, *args: Any, **kwargs: Any) -> AppStatus:
+        """Start the app, raises RuntimeError if an app is already running."""
+        if self.is_app_running():
+            raise RuntimeError("An app is already running")
+
+        (ep,) = entry_points(group="reachy_mini_apps", name=app_name)
+        app = ep.load()()
+
+        def wrapped_run() -> None:
+            assert self.current_app is not None
+
+            try:
+                self.current_app.status.state = AppState.RUNNING
+                self.logger.getChild("runner").info(f"App {app_name} is running")
+                app.wrapped_run(*args, **kwargs)
+                self.current_app.status.state = AppState.DONE
+                self.logger.getChild("runner").info(f"App {app_name} finished")
+            except Exception as e:
+                self.logger.getChild("runner").error(
+                    f"An error occurred in the app {app_name}: {e}"
+                )
+                self.logger.getChild("runner").error(
+                    f"Exception details: '{app.error}'",
+                )
+                self.current_app.status.state = AppState.ERROR
+                self.current_app.status.error = str(app.error)
+
+        self.current_app = RunningApp(
+            status=AppStatus(
+                info=AppInfo(name=app_name, source_kind=SourceKind.INSTALLED),
+                state=AppState.STARTING,
+                error=None,
+            ),
+            app=app,
+            thread=Thread(target=wrapped_run),
+        )
+        self.logger.getChild("runner").info(f"Starting app {app_name}")
+        self.current_app.thread.start()
+
+        return self.current_app.status
+
+    async def stop_current_app(self, timeout: float | None = 5.0) -> None:
+        """Stop the current app."""
+        if not self.is_app_running():
+            raise RuntimeError("No app is currently running")
+
+        assert self.current_app is not None
+
+        self.current_app.status.state = AppState.STOPPING
+        self.logger.getChild("runner").info(
+            f"Stopping app {self.current_app.status.info.name}"
+        )
+        self.current_app.app.stop()
+        self.current_app.thread.join(timeout)
+
+        if self.current_app.thread.is_alive():
+            self.logger.getChild("runner").warning(
+                "The app did not stop within the timeout"
+            )
+        else:
+            self.logger.getChild("runner").info("App stopped successfully")
+
+        self.current_app = None
+
+    async def restart_current_app(self) -> AppStatus:
+        """Restart the current app."""
+        if not self.is_app_running():
+            raise RuntimeError("No app is currently running")
+
+        assert self.current_app is not None
+
+        app_info = self.current_app.status.info
+
+        await self.stop_current_app()
+        await self.start_app(app_info.name)
+
+        return self.current_app.status
+
+    async def current_app_status(self) -> Optional[AppStatus]:
+        """Get the current status of the app."""
+        if self.current_app is not None:
+            return self.current_app.status
+        return None
+
+    # Apps management interface
+    async def list_all_available_apps(self) -> list[AppInfo]:
+        """List available apps (parallel async)."""
+        results = await asyncio.gather(
+            *[self.list_available_apps(kind) for kind in SourceKind]
+        )
+        return sum(results, [])
+
+    async def list_available_apps(self, source: SourceKind) -> list[AppInfo]:
+        """List available apps for given source kind."""
+        if source == SourceKind.HF_SPACE:
+            return await hf_space.list_all_apps()
+        elif source == SourceKind.DASHBOARD_SELECTION:
+            return await hf_space.list_available_apps()
+        elif source == SourceKind.INSTALLED:
+            return await local_common_venv.list_available_apps()
+        elif source == SourceKind.LOCAL:
+            return []
+        else:
+            raise NotImplementedError(f"Unknown source kind: {source}")
+
+    async def install_new_app(self, app: AppInfo, logger: logging.Logger) -> None:
+        """Install a new app by name."""
+        success = await local_common_venv.install_package(app, logger)
+        if success != 0:
+            raise RuntimeError(f"Failed to install app '{app.name}'")
+
+    async def remove_app(self, app_name: str, logger: logging.Logger) -> None:
+        """Remove an installed app by name."""
+        success = await local_common_venv.uninstall_package(app_name, logger)
+        if success != 0:
+            raise RuntimeError(f"Failed to uninstall app '{app_name}'")

reachy_mini/src/reachy_mini/apps/sources/__init__.py

@@ -0,0 +1,4 @@
+"""Specific app sources.
+
+For the moment, only huggingface spaces is implemented.
+"""

reachy_mini/src/reachy_mini/apps/sources/hf_space.py

@@ -0,0 +1,105 @@
+"""Hugging Face Spaces app source."""
+
+import asyncio
+import json
+from typing import Any, Dict
+
+import aiohttp
+
+from .. import AppInfo, SourceKind
+
+# Constants
+AUTHORIZED_APP_LIST_URL = "https://huggingface.co/datasets/pollen-robotics/reachy-mini-official-app-store/raw/main/app-list.json"
+HF_SPACES_API_URL = "https://huggingface.co/api/spaces"
+HF_SPACES_FILTER_URL = "https://huggingface.co/api/spaces?filter=reachy_mini&sort=likes&direction=-1&limit=50&full=true"
+REQUEST_TIMEOUT = aiohttp.ClientTimeout(total=30)
+
+
+async def _fetch_space_data(
+    session: aiohttp.ClientSession, space_id: str
+) -> Dict[str, Any] | None:
+    """Fetch data for a single space from Hugging Face API."""
+    url = f"{HF_SPACES_API_URL}/{space_id}"
+    try:
+        async with session.get(url, timeout=REQUEST_TIMEOUT) as response:
+            if response.status == 200:
+                data: Dict[str, Any] = await response.json()
+                return data
+            else:
+                return None
+    except (aiohttp.ClientError, asyncio.TimeoutError):
+        return None
+
+
+async def list_available_apps() -> list[AppInfo]:
+    """List apps available on Hugging Face Spaces."""
+    async with aiohttp.ClientSession(timeout=REQUEST_TIMEOUT) as session:
+        # Fetch the list of authorized app IDs
+        try:
+            async with session.get(AUTHORIZED_APP_LIST_URL) as response:
+                response.raise_for_status()
+                text = await response.text()
+                authorized_ids = json.loads(text)
+        except (aiohttp.ClientError, json.JSONDecodeError):
+            return []
+
+        if not isinstance(authorized_ids, list):
+            return []
+
+        # Filter to only string elements
+        authorized_ids = [
+            space_id for space_id in authorized_ids if isinstance(space_id, str)
+        ]
+
+        # Fetch data for each space in parallel
+        tasks = [_fetch_space_data(session, space_id) for space_id in authorized_ids]
+        spaces_data = await asyncio.gather(*tasks)
+
+        # Build AppInfo list from fetched data
+        apps = []
+        for item in spaces_data:
+            if item is None or "id" not in item:
+                continue
+
+            apps.append(
+                AppInfo(
+                    name=item["id"].split("/")[-1],
+                    description=item.get("cardData", {}).get("short_description", ""),
+                    url=f"https://huggingface.co/spaces/{item['id']}",
+                    source_kind=SourceKind.HF_SPACE,
+                    extra=item,
+                )
+            )
+
+        return apps
+
+
+async def list_all_apps() -> list[AppInfo]:
+    """List all apps available on Hugging Face Spaces (including unofficial ones)."""
+    async with aiohttp.ClientSession(timeout=REQUEST_TIMEOUT) as session:
+        try:
+            async with session.get(HF_SPACES_FILTER_URL) as response:
+                response.raise_for_status()
+                data: list[Dict[str, Any]] = await response.json()
+        except (aiohttp.ClientError, json.JSONDecodeError, asyncio.TimeoutError):
+            return []
+
+        if not isinstance(data, list):
+            return []
+
+        apps = []
+        for item in data:
+            if item is None or "id" not in item:
+                continue
+
+            apps.append(
+                AppInfo(
+                    name=item["id"].split("/")[-1],
+                    description=item.get("cardData", {}).get("short_description", ""),
+                    url=f"https://huggingface.co/spaces/{item['id']}",
+                    source_kind=SourceKind.HF_SPACE,
+                    extra=item,
+                )
+            )
+
+        return apps

reachy_mini/src/reachy_mini/apps/sources/local_common_venv.py

@@ -0,0 +1,61 @@
+"""Utilities for local common venv apps source."""
+
+import logging
+import sys
+from importlib.metadata import entry_points
+
+from .. import AppInfo, SourceKind
+from ..utils import running_command
+
+
+async def list_available_apps() -> list[AppInfo]:
+    """List apps available from entry points."""
+    entry_point_apps = list(entry_points(group="reachy_mini_apps"))
+
+    apps = []
+
+    for ep in entry_point_apps:
+        custom_app_url = None
+        try:
+            app = ep.load()
+            custom_app_url = app.custom_app_url
+        except Exception as e:
+            logging.getLogger("reachy_mini.apps").warning(
+                f"Could not load app '{ep.name}' from entry point: {e}"
+            )
+        apps.append(
+            AppInfo(
+                name=ep.name,
+                source_kind=SourceKind.INSTALLED,
+                extra={"custom_app_url": custom_app_url},
+            )
+        )
+
+    return apps
+
+
+async def install_package(app: AppInfo, logger: logging.Logger) -> int:
+    """Install a package given an AppInfo object, streaming logs."""
+    if app.source_kind == SourceKind.HF_SPACE:
+        target = f"git+{app.url}" if app.url is not None else app.name
+    elif app.source_kind == SourceKind.LOCAL:
+        target = app.extra.get("path", app.name)
+    else:
+        raise ValueError(f"Cannot install app from source kind '{app.source_kind}'")
+
+    return await running_command(
+        [sys.executable, "-m", "pip", "install", target],
+        logger=logger,
+    )
+
+
+async def uninstall_package(app_name: str, logger: logging.Logger) -> int:
+    """Uninstall a package given an app name."""
+    existing_apps = await list_available_apps()
+    if app_name not in [app.name for app in existing_apps]:
+        raise ValueError(f"Cannot uninstall app '{app_name}': it is not installed")
+
+    return await running_command(
+        [sys.executable, "-m", "pip", "uninstall", "-y", app_name],
+        logger=logger,
+    )

reachy_mini/src/reachy_mini/apps/templates/README.md.j2

@@ -0,0 +1,11 @@
+---
+title: {{ class_name_display }}
+emoji: 👋
+colorFrom: red
+colorTo: blue
+sdk: static
+pinned: false
+short_description: Write your description here
+tags:
+ - reachy_mini
+---

reachy_mini/src/reachy_mini/apps/templates/index.html.j2

@@ -0,0 +1,235 @@
+<!doctype html>
+<html>
+
+<head>
+	<meta charset="utf-8" />
+	<meta name="viewport" content="width=device-width" />
+	<title> {{ class_name_display }} </title>
+	<link rel="stylesheet" href="style.css" />
+</head>
+
+<body>
+	<div class="hero">
+		<div class="hero-content">
+			<div class="app-icon">🤖⚡</div>
+			<h1> {{ class_name_display }} </h1>
+			<p class="tagline">Enter your tagline here</p>
+		</div>
+	</div>
+
+	<div class="container">
+		<div class="main-card">
+			<div class="app-preview">
+				<div class="preview-image">
+					<div class="camera-feed">🛠️</div>
+				</div>
+			</div>
+		</div>
+	</div>
+
+	<div class="download-section">
+		<div class="download-card">
+			<h2>Install This App</h2>
+
+			<div class="dashboard-config">
+				<label for="dashboardUrl">Your Reachy Dashboard URL:</label>
+				<input type="url" id="dashboardUrl" value="http://localhost:8000"
+					placeholder="http://your-reachy-ip:8000" />
+			</div>
+
+			<button id="installBtn" class="install-btn primary">
+				<span class="btn-icon">📥</span>
+				Install {{ class_name_display }} to Reachy Mini
+			</button>
+
+			<div id="installStatus" class="install-status"></div>
+
+		</div>
+	</div>
+
+	<div class="footer">
+		<p>
+			🤖 {{ class_name_display }} •
+			<a href="https://github.com/pollen-robotics" target="_blank">Pollen Robotics</a> •
+			<a href="https://huggingface.co/spaces/pollen-robotics/Reachy_Mini_Apps" target="_blank">Browse More
+				Apps</a>
+		</p>
+	</div>
+	</div>
+
+	<script>
+		// Get the current Hugging Face Space URL as the repository URL
+		function getCurrentSpaceUrl() {
+			// Get current page URL and convert to repository format
+			const currentUrl = window.location.href;
+
+			// Remove any trailing slashes and query parameters
+			const cleanUrl = currentUrl.split('?')[0].replace(/\/$/, '');
+
+			return cleanUrl;
+		}
+
+		// Parse TOML content to extract project name
+		function parseTomlProjectName(tomlContent) {
+			try {
+				const lines = tomlContent.split('\n');
+				let inProjectSection = false;
+
+				for (const line of lines) {
+					const trimmedLine = line.trim();
+
+					// Check if we're entering the [project] section
+					if (trimmedLine === '[project]') {
+						inProjectSection = true;
+						continue;
+					}
+
+					// Check if we're entering a different section
+					if (trimmedLine.startsWith('[') && trimmedLine !== '[project]') {
+						inProjectSection = false;
+						continue;
+					}
+
+					// If we're in the project section, look for the name field
+					if (inProjectSection && trimmedLine.startsWith('name')) {
+						const match = trimmedLine.match(/name\s*=\s*["']([^"']+)["']/);
+						if (match) {
+							// Convert to lowercase and replace invalid characters for app naming
+							return match[1].toLowerCase().replace(/[^a-z0-9-_]/g, '-');
+						}
+					}
+				}
+
+				throw new Error('Project name not found in pyproject.toml');
+			} catch (error) {
+				console.error('Error parsing pyproject.toml:', error);
+				return 'unknown-app';
+			}
+		}
+
+		// Fetch and parse pyproject.toml from the current space
+		async function getAppNameFromCurrentSpace() {
+			try {
+				// Fetch pyproject.toml from the current space
+				const response = await fetch('./pyproject.toml');
+				if (!response.ok) {
+					throw new Error(`Failed to fetch pyproject.toml: ${response.status}`);
+				}
+
+				const tomlContent = await response.text();
+				return parseTomlProjectName(tomlContent);
+			} catch (error) {
+				console.error('Error fetching app name from current space:', error);
+				// Fallback to extracting from URL if pyproject.toml is not accessible
+				const url = getCurrentSpaceUrl();
+				const parts = url.split('/');
+				const spaceName = parts[parts.length - 1];
+				return spaceName.toLowerCase().replace(/[^a-z0-9-_]/g, '-');
+			}
+		}
+
+		async function installToReachy() {
+			const dashboardUrl = document.getElementById('dashboardUrl').value.trim();
+			const statusDiv = document.getElementById('installStatus');
+			const installBtn = document.getElementById('installBtn');
+
+			if (!dashboardUrl) {
+				showStatus('error', 'Please enter your Reachy dashboard URL');
+				return;
+			}
+
+			try {
+				installBtn.disabled = true;
+				installBtn.innerHTML = '<span class="btn-icon">⏳</span>Installing...';
+				showStatus('loading', 'Connecting to your Reachy dashboard...');
+
+				// Test connection
+				const testResponse = await fetch(`${dashboardUrl}/api/status`, {
+					method: 'GET',
+					mode: 'cors',
+				});
+
+				if (!testResponse.ok) {
+					throw new Error('Cannot connect to dashboard. Make sure the URL is correct and the dashboard is running.');
+				}
+
+				showStatus('loading', 'Reading app configuration...');
+
+				// Get app name from pyproject.toml in current space
+				const appName = await getAppNameFromCurrentSpace();
+
+				// Get current space URL as repository URL
+				const repoUrl = getCurrentSpaceUrl();
+
+				showStatus('loading', `Starting installation of "${appName}"...`);
+
+				// Start installation
+				const installResponse = await fetch(`${dashboardUrl}/api/install`, {
+					method: 'POST',
+					mode: 'cors',
+					headers: {
+						'Content-Type': 'application/json',
+					},
+					body: JSON.stringify({
+						url: repoUrl,
+						name: appName
+					})
+				});
+
+				const result = await installResponse.json();
+
+				if (installResponse.ok) {
+					showStatus('success', `✅ Installation started for "${appName}"! Check your dashboard for progress.`);
+					setTimeout(() => {
+						showStatus('info', `Open your dashboard at ${dashboardUrl} to see the installed app.`);
+					}, 3000);
+				} else {
+					throw new Error(result.detail || 'Installation failed');
+				}
+
+			} catch (error) {
+				console.error('Installation error:', error);
+				showStatus('error', `❌ ${error.message}`);
+			} finally {
+				installBtn.disabled = false;
+				installBtn.innerHTML = '<span class="btn-icon">📥</span>Install App to Reachy';
+			}
+		}
+
+		function showStatus(type, message) {
+			const statusDiv = document.getElementById('installStatus');
+			statusDiv.className = `install-status ${type}`;
+			statusDiv.textContent = message;
+			statusDiv.style.display = 'block';
+		}
+
+		function copyToClipboard() {
+			const repoUrl = document.getElementById('repoUrl').textContent;
+			navigator.clipboard.writeText(repoUrl).then(() => {
+				showStatus('success', '📋 Repository URL copied to clipboard!');
+			}).catch(() => {
+				showStatus('error', 'Failed to copy URL. Please copy manually.');
+			});
+		}
+
+		// Update the displayed repository URL on page load
+		document.addEventListener('DOMContentLoaded', () => {
+			// Auto-detect local dashboard
+			const isLocalhost = window.location.hostname === 'localhost' || window.location.hostname === '127.0.0.1';
+			if (isLocalhost) {
+				document.getElementById('dashboardUrl').value = 'http://localhost:8000';
+			}
+
+			// Update the repository URL display if element exists
+			const repoUrlElement = document.getElementById('repoUrl');
+			if (repoUrlElement) {
+				repoUrlElement.textContent = getCurrentSpaceUrl();
+			}
+		});
+
+		// Event listeners
+		document.getElementById('installBtn').addEventListener('click', installToReachy);
+	</script>
+</body>
+
+</html>

reachy_mini/src/reachy_mini/apps/templates/main.py.j2

@@ -0,0 +1,50 @@
+import threading
+
+from reachy_mini import ReachyMini, ReachyMiniApp
+from reachy_mini.utils import create_head_pose
+
+
+class {{ class_name }}(ReachyMiniApp):
+    # Optional: URL to a custom configuration page for the app
+    # eg. "http://localhost:8042/settings"
+    custom_app_url: str | None = None 
+
+    def run(self, reachy_mini: ReachyMini, stop_event: threading.Event):
+        # Write your code here
+        # ReachyMini is already initialized and connected
+        # Check the stop_event to gracefully exit the loop
+        # Example:
+        # import time
+        # import numpy as np
+        #
+        # t0 = time.time()
+        #
+        # while not stop_event.is_set():
+        #     t = time.time() - t0
+        #
+        #     yaw = 30 * np.sin(2 * np.pi * 0.5 * t)
+        #     head_pose = create_head_pose(yaw=yaw, degrees=True) 
+        #
+        #     reachy_mini.set_target(head=head_pose)
+        #
+        #     time.sleep(0.01)
+
+        print("This is a placeholder for your app logic.")
+
+
+if __name__ == "__main__":
+    # You can run the app directly from this script
+    with ReachyMini() as mini:
+        app = {{ class_name }}()
+
+        stop = threading.Event()
+
+        try:
+            print("Running '{{ app_name }}' a ReachyMiniApp...")
+            print("Press Ctrl+C to stop the app.")
+            app.run(mini, stop)
+            print("App has stopped.")
+
+        except KeyboardInterrupt:
+            print("Stopping the app...")
+            stop.set()

reachy_mini/src/reachy_mini/apps/templates/pyproject.toml.j2

@@ -0,0 +1,18 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+
+[project]
+name = "{{ app_name }}"
+version = "0.1.0"
+description = "Add your description here"
+readme = "README.md"
+requires-python = ">=3.10"
+dependencies = [
+    "reachy-mini"
+]
+keywords = ["reachy-mini-app"]
+
+[project.entry-points."reachy_mini_apps"]
+{{ app_name }} = "{{ module_name }}.main:{{ class_name }}"

reachy_mini/src/reachy_mini/apps/templates/style.css.j2

@@ -0,0 +1,411 @@
+* {
+	margin: 0;
+	padding: 0;
+	box-sizing: border-box;
+}
+
+body {
+	font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, "Helvetica Neue", Arial, sans-serif;
+	line-height: 1.6;
+	color: #333;
+	background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+	min-height: 100vh;
+}
+
+.hero {
+	background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+	color: white;
+	padding: 4rem 2rem;
+	text-align: center;
+}
+
+.hero-content {
+	max-width: 800px;
+	margin: 0 auto;
+}
+
+.app-icon {
+	font-size: 4rem;
+	margin-bottom: 1rem;
+	display: inline-block;
+}
+
+.hero h1 {
+	font-size: 3rem;
+	font-weight: 700;
+	margin-bottom: 1rem;
+	background: linear-gradient(45deg, #fff, #f0f9ff);
+	background-clip: text;
+	-webkit-background-clip: text;
+	-webkit-text-fill-color: transparent;
+}
+
+.tagline {
+	font-size: 1.25rem;
+	opacity: 0.9;
+	max-width: 600px;
+	margin: 0 auto;
+}
+
+.container {
+	max-width: 1200px;
+	margin: 0 auto;
+	padding: 0 2rem;
+	position: relative;
+	z-index: 2;
+}
+
+.main-card {
+	background: white;
+	border-radius: 20px;
+	box-shadow: 0 20px 40px rgba(0, 0, 0, 0.1);
+	margin-top: -2rem;
+	overflow: hidden;
+	margin-bottom: 3rem;
+}
+
+.app-preview {
+	background: linear-gradient(135deg, #1e3a8a, #3b82f6);
+	padding: 3rem;
+	color: white;
+	text-align: center;
+	position: relative;
+}
+
+.preview-image {
+	background: #000;
+	border-radius: 15px;
+	padding: 2rem;
+	max-width: 500px;
+	margin: 0 auto;
+	position: relative;
+	overflow: hidden;
+}
+
+.camera-feed {
+	font-size: 4rem;
+	margin-bottom: 1rem;
+	opacity: 0.7;
+}
+
+.detection-overlay {
+	position: absolute;
+	top: 50%;
+	left: 50%;
+	transform: translate(-50%, -50%);
+	width: 100%;
+}
+
+.bbox {
+	background: rgba(34, 197, 94, 0.9);
+	color: white;
+	padding: 0.5rem 1rem;
+	border-radius: 8px;
+	font-size: 0.9rem;
+	font-weight: 600;
+	margin: 0.5rem;
+	display: inline-block;
+	border: 2px solid #22c55e;
+}
+
+.app-details {
+	padding: 3rem;
+}
+
+.app-details h2 {
+	font-size: 2rem;
+	color: #1e293b;
+	margin-bottom: 2rem;
+	text-align: center;
+}
+
+.template-info {
+	display: grid;
+	grid-template-columns: repeat(auto-fit, minmax(300px, 1fr));
+	gap: 2rem;
+	margin-bottom: 3rem;
+}
+
+.info-box {
+	background: #f0f9ff;
+	border: 2px solid #e0f2fe;
+	border-radius: 12px;
+	padding: 2rem;
+}
+
+.info-box h3 {
+	color: #0c4a6e;
+	margin-bottom: 1rem;
+	font-size: 1.2rem;
+}
+
+.info-box p {
+	color: #0369a1;
+	line-height: 1.6;
+}
+
+.how-to-use {
+	background: #fefce8;
+	border: 2px solid #fde047;
+	border-radius: 12px;
+	padding: 2rem;
+	margin-top: 3rem;
+}
+
+.how-to-use h3 {
+	color: #a16207;
+	margin-bottom: 1.5rem;
+	font-size: 1.3rem;
+	text-align: center;
+}
+
+.steps {
+	display: flex;
+	flex-direction: column;
+	gap: 1.5rem;
+}
+
+.step {
+	display: flex;
+	align-items: flex-start;
+	gap: 1rem;
+}
+
+.step-number {
+	background: #eab308;
+	color: white;
+	width: 2rem;
+	height: 2rem;
+	border-radius: 50%;
+	display: flex;
+	align-items: center;
+	justify-content: center;
+	font-weight: bold;
+	flex-shrink: 0;
+}
+
+.step h4 {
+	color: #a16207;
+	margin-bottom: 0.5rem;
+	font-size: 1.1rem;
+}
+
+.step p {
+	color: #ca8a04;
+}
+
+.download-card {
+	background: white;
+	border-radius: 20px;
+	box-shadow: 0 20px 40px rgba(0, 0, 0, 0.1);
+	padding: 3rem;
+	text-align: center;
+}
+
+.download-card h2 {
+	font-size: 2rem;
+	color: #1e293b;
+	margin-bottom: 1rem;
+}
+
+.download-card>p {
+	color: #64748b;
+	font-size: 1.1rem;
+	margin-bottom: 2rem;
+}
+
+.dashboard-config {
+	margin-bottom: 2rem;
+	text-align: left;
+	max-width: 400px;
+	margin-left: auto;
+	margin-right: auto;
+}
+
+.dashboard-config label {
+	display: block;
+	color: #374151;
+	font-weight: 600;
+	margin-bottom: 0.5rem;
+}
+
+.dashboard-config input {
+	width: 100%;
+	padding: 0.75rem 1rem;
+	border: 2px solid #e5e7eb;
+	border-radius: 8px;
+	font-size: 0.95rem;
+	transition: border-color 0.2s;
+}
+
+.dashboard-config input:focus {
+	outline: none;
+	border-color: #667eea;
+}
+
+.install-btn {
+	background: linear-gradient(135deg, #667eea, #764ba2);
+	color: white;
+	border: none;
+	padding: 1.25rem 3rem;
+	border-radius: 16px;
+	font-size: 1.2rem;
+	font-weight: 700;
+	cursor: pointer;
+	transition: all 0.3s ease;
+	display: inline-flex;
+	align-items: center;
+	gap: 0.75rem;
+	margin-bottom: 2rem;
+	box-shadow: 0 8px 25px rgba(102, 126, 234, 0.3);
+}
+
+.install-btn:hover:not(:disabled) {
+	transform: translateY(-3px);
+	box-shadow: 0 15px 35px rgba(102, 126, 234, 0.4);
+}
+
+.install-btn:disabled {
+	opacity: 0.7;
+	cursor: not-allowed;
+	transform: none;
+}
+
+.manual-option {
+	background: #f8fafc;
+	border-radius: 12px;
+	padding: 2rem;
+	margin-top: 2rem;
+}
+
+.manual-option h3 {
+	color: #1e293b;
+	margin-bottom: 1rem;
+	font-size: 1.2rem;
+}
+
+.manual-option>p {
+	color: #64748b;
+	margin-bottom: 1rem;
+}
+
+.btn-icon {
+	font-size: 1.1rem;
+}
+
+.install-status {
+	padding: 1rem;
+	border-radius: 8px;
+	font-size: 0.9rem;
+	text-align: center;
+	display: none;
+	margin-top: 1rem;
+}
+
+.install-status.success {
+	background: #dcfce7;
+	color: #166534;
+	border: 1px solid #bbf7d0;
+}
+
+.install-status.error {
+	background: #fef2f2;
+	color: #dc2626;
+	border: 1px solid #fecaca;
+}
+
+.install-status.loading {
+	background: #dbeafe;
+	color: #1d4ed8;
+	border: 1px solid #bfdbfe;
+}
+
+.install-status.info {
+	background: #e0f2fe;
+	color: #0369a1;
+	border: 1px solid #7dd3fc;
+}
+
+.manual-install {
+	background: #1f2937;
+	border-radius: 8px;
+	padding: 1rem;
+	margin-bottom: 1rem;
+	display: flex;
+	align-items: center;
+	gap: 1rem;
+}
+
+.manual-install code {
+	color: #10b981;
+	font-family: 'SF Mono', 'Monaco', 'Inconsolata', 'Roboto Mono', monospace;
+	font-size: 0.85rem;
+	flex: 1;
+	overflow-x: auto;
+}
+
+.copy-btn {
+	background: #374151;
+	color: white;
+	border: none;
+	padding: 0.5rem 1rem;
+	border-radius: 6px;
+	font-size: 0.8rem;
+	cursor: pointer;
+	transition: background-color 0.2s;
+}
+
+.copy-btn:hover {
+	background: #4b5563;
+}
+
+.manual-steps {
+	color: #6b7280;
+	font-size: 0.9rem;
+	line-height: 1.8;
+}
+
+.footer {
+	text-align: center;
+	padding: 2rem;
+	color: white;
+	opacity: 0.8;
+}
+
+.footer a {
+	color: white;
+	text-decoration: none;
+	font-weight: 600;
+}
+
+.footer a:hover {
+	text-decoration: underline;
+}
+
+/* Responsive Design */
+@media (max-width: 768px) {
+	.hero {
+		padding: 2rem 1rem;
+	}
+
+	.hero h1 {
+		font-size: 2rem;
+	}
+
+	.container {
+		padding: 0 1rem;
+	}
+
+	.app-details,
+	.download-card {
+		padding: 2rem;
+	}
+
+	.features-grid {
+		grid-template-columns: 1fr;
+	}
+
+	.download-options {
+		grid-template-columns: 1fr;
+	}
+}

reachy_mini/src/reachy_mini/apps/utils.py

@@ -0,0 +1,30 @@
+"""Utility functions for Reachy Mini apps manager."""
+
+import asyncio
+import logging
+
+
+async def running_command(command: list[str], logger: logging.Logger) -> int:
+    """Run a shell command and stream its output to the provided logger."""
+    logger.info(f"Running command: {' '.join(command)}")
+
+    proc = await asyncio.create_subprocess_exec(
+        *command, stdout=asyncio.subprocess.PIPE, stderr=asyncio.subprocess.PIPE
+    )
+
+    assert proc.stdout is not None  # for mypy
+    assert proc.stderr is not None  # for mypy
+
+    # Stream output line by line
+    while True:
+        line = await proc.stdout.readline()
+        if not line:
+            break
+        logger.info(line.decode().rstrip())
+
+    # Also log any remaining stderr
+    err = await proc.stderr.read()
+    if err:
+        logger.error(err.decode().rstrip())
+
+    return await proc.wait()

reachy_mini/src/reachy_mini/assets/config/hardware_config.yaml

@@ -0,0 +1,155 @@
+version: beta
+
+serial:
+  baudrate: 1000000
+
+# Limits measured on the robot (in degrees)
+# s1 
+# lower : -48° : -546
+# upper : +80° : 910
+
+# s2
+# lower: +70° : 796
+# upper: -80° : -910
+
+# s3
+# lower: -48° : -546
+# upper: +80° : 910
+
+# s4
+# lower: +48° : 546
+# upper: -80° : -910
+
+# s5
+# lower: -70° : -796
+# upper: +80° : 910
+
+# s6
+# lower : +48° : 546
+# upper : -80° : -910
+
+# s1:
+#     lower: 2048 - 546 : 1502
+#     upper: 2048 + 910 : 2958
+
+# s2: 
+#     lower: 2048 - 910 : 1138
+#     upper: 2048 + 796 : 2844
+
+# s3: 
+#     lower: 2048 - 546 : 1502
+#     upper: 2048 + 910 : 2958
+
+# s4: 
+#     lower: 2048 - 910 : 1138
+#     upper: 2048 + 546 : 2594
+
+# s5:
+#     lower: 2048 - 796 : 1252
+#     upper: 2048 + 910 : 2958
+
+# s6:
+#     lower: 2048 - 910 : 1138
+#     upper: 2048 + 546 : 2594
+
+
+motors:
+  - body_rotation:
+      id: 10
+      offset: 0
+      lower_limit: 0
+      upper_limit: 4095
+      return_delay_time: 0
+      shutdown_error: 52
+      pid: 
+        - 400
+        - 0
+        - 0
+  - stewart_1:
+      id: 11
+      offset: 1024
+      lower_limit: 1502
+      upper_limit: 2958
+      return_delay_time: 0
+      shutdown_error: 52
+      pid:
+        - 400
+        - 0
+        - 0
+  - stewart_2:
+      id: 12
+      offset: -1024
+      lower_limit: 1138
+      upper_limit: 2844
+      return_delay_time: 0
+      shutdown_error: 52
+      pid:
+        - 400
+        - 0
+        - 0
+  - stewart_3:
+      id: 13
+      offset: 1024
+      lower_limit: 1502
+      upper_limit: 2958
+      return_delay_time: 0
+      shutdown_error: 52
+      pid:
+        - 400
+        - 0
+        - 0
+  - stewart_4:
+      id: 14
+      offset: -1024
+      lower_limit: 1138
+      upper_limit: 2594
+      return_delay_time: 0
+      shutdown_error: 52
+      pid:
+        - 400
+        - 0
+        - 0
+  - stewart_5:
+      id: 15
+      offset: 1024
+      lower_limit: 1252
+      upper_limit: 2958
+      return_delay_time: 0
+      shutdown_error: 52
+      pid:
+        - 400
+        - 0
+        - 0
+  - stewart_6:
+      id: 16
+      offset: -1024
+      lower_limit: 1138
+      upper_limit: 2594
+      return_delay_time: 0
+      shutdown_error: 52
+      pid:
+        - 400
+        - 0
+        - 0
+  - right_antenna:
+      id: 17
+      offset: 0
+      lower_limit: 0
+      upper_limit: 4095
+      return_delay_time: 0
+      shutdown_error: 52
+      pid:
+        - 400
+        - 0
+        - 400
+  - left_antenna:
+      id: 18
+      offset: 0
+      lower_limit: 0
+      upper_limit: 4095
+      return_delay_time: 0
+      shutdown_error: 52
+      pid:
+        - 400
+        - 0
+        - 400

reachy_mini/src/reachy_mini/assets/firmware/CHANGELOG.md

@@ -0,0 +1,15 @@
+# Changelog of Reachy Mini Audio Firmware
+
+
+## 2.1.3
+
+*For Beta units only*
+
+Fixes the initialization issue on Reachy Mini beta hardware. An additional 2-second delay is added during initialization to prevent the XMOS chip from starting before the other components.
+
+There is no need to apply this firmware to the Lite and Wireless versions, as the issue is fixed at the hardware level.
+
+## 2.1.2
+
+Improved parameters for acoustic echo cancellation (AEC).
+PP_DTSENSITIVE is set to 1 by default.

reachy_mini/src/reachy_mini/assets/firmware/reachymini_ua_io16_lin_v2.1.2.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:661429a93b155cdbfed1e6c214820fd42e3372a08c3930f14fcd4e6db5be6796
+size 933888

reachy_mini/src/reachy_mini/assets/firmware/reachymini_ua_io16_lin_v2.1.3.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0e35fa9a43a4e75890fd6299e62e85310d8081087e6a9702aaef0c81bd3af283
+size 933888

reachy_mini/src/reachy_mini/assets/firmware/update.sh

@@ -0,0 +1,9 @@
+#!/bin/bash
+# Firmware update script for Reachy Mini
+# Usage: ./update.sh <firmware_file>
+firmware="$1"
+if [ -z "$firmware" ]; then
+    echo "Usage: $0 <firmware_file>"
+    exit 1
+fi
+dfu-util -R -e -a 1 -D "$firmware"