Skip to content
Back to search

RockyVoice

A Claude skill. You turn on, Claude is not Claude. Claude is Rocky. The Eridian. From Andy Weir's Project Hail Mary.

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today
Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/lagunaswift--rockyvoice/badge.svg)](/listings/lagunaswift--rockyvoice)

HTML

<a href="/listings/lagunaswift--rockyvoice"><img src="/api/listings/lagunaswift--rockyvoice/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

cd rocky-tts
cp .env.example .env
# Edit .env — add your Hume API key
# Then clone your own Rocky voice (see "Voice setup" below) and add its id.
# No id yet? It still runs with a stock fallback voice.
npm install
npm start

Open **http://localhost:3333** in your browser and click **Initialize** to enable audio.

The Eridian Translator UI shows a waveform visualizer and translation log. It receives audio via the Claude Code hook below. Use the **volume slider** to adjust loudness and the **stop button** to kill audio mid-playback.

**Hook setup** — add a Stop hook to your Claude Code settings so Rocky's responses play automatically:

Add this to `.claude/settings.local.json`:

{
  "hooks": {
    "Stop": [
      {
        "hooks": [
          {
            "type": "http",
            "url": "http://localhost:3333/api/hook",
            "timeout": 5,
            "statusMessage": "Rocky voice..."
          }
        ]
      }
    ],
    "SessionStart": [
      {
        "hooks": [
          {
            "type": "command",
            "command": "cd /path/to/rocky-tts && node server.js",
            "async": true,
            "statusMessage": "Starting Rocky voice..."
          }
        ]
      }
    ]
  }
}

The `Stop` hook sends Rocky's words to the voice server after every response. The `SessionStart` hook starts the server automatically when you open Claude Code — no manual `npm start` needed. Change `/path/to/rocky-tts` to wherever you cloned the repo.

**On Windows**, the `SessionStart` `command` above is bash and won't run. Use a PowerShell command instead (and add `"shell": "powershell"` to that hook). This version also skips starting a second server if one is already running:

{
  "type": "command",
  "shell": "powershell",
  "command": "if (-not (Get-NetTCPConnection -LocalPort 3333 -State Listen -ErrorAction SilentlyContinue)) { Start-Process node -ArgumentList 'server.js' -WorkingDirectory 'C:\\path\\to\\rocky-tts' -WindowStyle Hidden }",
  "async": true,
  "statusMessage": "Starting Rocky voice..."
}

Then activate the Rocky skill, open **http://localhost:3333** in your browser, click **Initialize** once, and every response speaks automatically.

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

README.md · README · 309 lines · 2 findings marked

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

  1. <p align="center"><img width="700" height="500" alt="Image" src="https://github.com/user-attachments/assets/6cf084cc-8c53-435e-9cfe-65b63389fd8f" />
  2. <p align="center"><strong>talk to space friend now</strong></p>
  3. # rocky-voice
  4. A Claude Code / Hermes skill + voice app. You turn on, assistant is not normal assistant. Assistant is **Rocky**. The Eridian. From Andy Weir's *Project Hail Mary*.
  5. Small words. Big brain. Question goes at end, question?
  6. Two parts:
  7. 1. **Text** — Claude Code and Hermes skills. Rocky talks in text. Install the skill, activate, done.
  8. 2. **Voice** — a local web app plus Hermes command-provider wrapper. Rocky talks out loud. Powered by [Hume AI](https://hume.ai) TTS with a custom Rocky voice clone.
  9. ## What it does
  10. Claude talks like Rocky for the whole conversation. Short words. No contractions. Broken grammar that still lands. Tripled word means big big big feeling. "question" goes at the end.
  11. The brain stays full. Full full full. Only the words are small. You ask hard thing — code thing, science thing — Rocky gives correct answer. Rocky just says it like engineer who learned English from one human, fast.
  12. ## Before / after
  13. **Normal Claude:**
  14. > "The reason your component re-renders is that you're passing a new object reference on every render. React's shallow comparison treats it as a different prop each time. Wrap it in `useMemo`."
  15. **Rocky:**
  16. > "New object every render. React sees new thing, draws again. Wrap in `useMemo`. Good good good."
  17. Same fix. Rocky voice.
  18. ---
  19. ## Part 1: Text skill
  20. ### Claude Code
  21. Drop the skill into your Claude skills folder.
  22. ```bash
  23. curl -fsSL https://raw.githubusercontent.com/Lagunaswift/RockyVoice/main/install.sh | bash
    • Note: Pipes a downloaded script directly into a shell (curl | sh / wget | bash)
    • Line 41 on GitHub
  24. ```
  25. Or by hand: copy `rocky-voice/SKILL.md` into your Claude skills directory.
  26. ### Hermes
  27. Install the Hermes-native skill into your Hermes skills folder.
  28. ```bash
  29. curl -fsSL https://raw.githubusercontent.com/Lagunaswift/RockyVoice/main/install.sh | bash -s -- --hermes
    • Note: Pipes a downloaded script directly into a shell (curl | sh / wget | bash)
    • Line 51 on GitHub
  30. ```
  31. Or by hand: copy `hermes/rocky-voice/SKILL.md` into `~/.hermes/skills/creative/rocky-voice/SKILL.md`.
  32. No Node needed for text-only mode. One file.
  33. ## Part 2: Voice app
  34. Hear Rocky speak. Requires a [Hume AI](https://hume.ai) account and API key.
  35. ### Setup
  36. ```bash
  37. cd rocky-tts
  38. cp .env.example .env
  39. # Edit .env — add your Hume API key
  40. # Then clone your own Rocky voice (see "Voice setup" below) and add its id.
  41. # No id yet? It still runs with a stock fallback voice.
  42. npm install
  43. npm start
  44. ```
  45. Open **http://localhost:3333** in your browser and click **Initialize** to enable audio.
  46. The Eridian Translator UI shows a waveform visualizer and translation log. It receives audio via the Claude Code hook below. Use the **volume slider** to adjust loudness and the **stop button** to kill audio mid-playback.
  47. **Hook setup** — add a Stop hook to your Claude Code settings so Rocky's responses play automatically:
  48. Add this to `.claude/settings.local.json`:
  49. ```json
  50. {
  51. "hooks": {
  52. "Stop": [
  53. {
  54. "hooks": [
  55. {
  56. "type": "http",
  57. "url": "http://localhost:3333/api/hook",
  58. "timeout": 5,
  59. "statusMessage": "Rocky voice..."
  60. }
  61. ]
  62. }
  63. ],
  64. "SessionStart": [
  65. {
  66. "hooks": [
  67. {
  68. "type": "command",
  69. "command": "cd /path/to/rocky-tts && node server.js",
  70. "async": true,
  71. "statusMessage": "Starting Rocky voice..."
  72. }
  73. ]
  74. }
  75. ]
  76. }
  77. }
  78. ```
  79. The `Stop` hook sends Rocky's words to the voice server after every response. The `SessionStart` hook starts the server automatically when you open Claude Code — no manual `npm start` needed. Change `/path/to/rocky-tts` to wherever you cloned the repo.
  80. **On Windows**, the `SessionStart` `command` above is bash and won't run. Use a PowerShell command instead (and add `"shell": "powershell"` to that hook). This version also skips starting a second server if one is already running:
  81. ```json
  82. {
  83. "type": "command",
  84. "shell": "powershell",
  85. "command": "if (-not (Get-NetTCPConnection -LocalPort 3333 -State Listen -ErrorAction SilentlyContinue)) { Start-Process node -ArgumentList 'server.js' -WorkingDirectory 'C:\\path\\to\\rocky-tts' -WindowStyle Hidden }",
  86. "async": true,
  87. "statusMessage": "Starting Rocky voice..."
  88. }
  89. ```
  90. Then activate the Rocky skill, open **http://localhost:3333** in your browser, click **Initialize** once, and every response speaks automatically.
  91. ### Hermes TTS command provider
  92. Hermes does not use Claude hooks. It can call RockyVoice as a local TTS command provider. Start the RockyVoice server first:
  93. ```bash
  94. cd rocky-tts
  95. npm install
  96. npm start
  97. ```
  98. Then add a provider to your Hermes config. Change `/path/to/RockyVoice` to your clone path:
  99. ```yaml
  100. tts:
  101. provider: rocky
  102. providers:
  103. rocky:
  104. type: command
  105. command: "node /path/to/RockyVoice/rocky-tts/hermes-tts.js --text-file {input_path} --output {output_path}"
  106. output_format: wav
  107. timeout: 120
  108. voice_compatible: true
  109. ```
  110. The wrapper calls `http://127.0.0.1:3333/api/tts` and writes a WAV file for Hermes. If your server runs somewhere else, set `ROCKY_TTS_URL`, for example:
  111. ```bash
  112. ROCKY_TTS_URL=http://127.0.0.1:3333 node rocky-tts/hermes-tts.js --text-file input.txt --output output.wav
  113. ```
  114. For Hermes text style, install the Hermes skill from `hermes/rocky-voice/SKILL.md` and activate it in Hermes. For spoken output, configure the TTS provider above.
  115. ### Optional: allow Rocky's live progress voice lines
  116. Rocky can narrate what he's doing between tool calls (short spoken updates like "Rocky looking at files now"). These are sent via `curl` to the local TTS server. To avoid a permission prompt on every line, add this to your `.claude/settings.local.json` permissions:
  117. ```json
  118. {
  119. "permissions": {
  120. "allow": [
  121. "Bash(curl -s -X POST http://localhost:3333/*)",
  122. "Bash(curl -s -o /dev/null *)"
  123. ]
  124. }
  125. }
  126. ```
  127. If you already have a `permissions.allow` array (e.g. from the hook setup above), merge these entries into it. After adding, **restart Claude Code** for the wildcard rules to take effect.
  128. ### Quick setup checklist (new machine)
  129. 1. Clone the repo: `git clone https://github.com/Lagunaswift/RockyVoice.git`
  130. 2. `cd RockyVoice/rocky-tts && cp .env.example .env`
  131. 3. Edit `.env` — add your Hume API key (and optionally clone a Rocky voice, see below)
  132. 4. `npm install`
  133. 5. Install the Rocky skill: copy `rocky-voice/SKILL.md` into `~/.claude/skills/rocky-voice/`
  134. 6. Open the RockyVoice folder in Claude Code and activate the Rocky skill
  135. 7. **Rocky auto-configures the rest.** The skill detects missing hooks, permissions, and server state — then sets them up. You just need to open **http://localhost:3333** and click **Initialize** when Rocky tells you to.
  136. A settings template is included at `.claude/settings.local.json.example` if you prefer to configure manually.
  137. > **How auto-setup works:** The skill file contains a setup checklist that Claude runs on activation. It writes the Stop hook (sends responses to TTS), adds curl permissions (for progress voice lines), installs dependencies if needed, starts the server, and verifies the connection. The only manual steps are adding your Hume API key and clicking Initialize in the browser.
  138. ### Voice setup — clone your own Rocky (~1 minute, one time)
  139. Voice clones on Hume are **private to the account that made them** — a shared voice id returns `404` for everyone else. So each person makes their own from the same source audio. Same recording in, same Rocky out.
  140. This repo ships a source clip: [`rocky-tts/public/RockyVoice-James.wav`](rocky-tts/public/RockyVoice-James.wav).
  141. 1. Sign in at [platform.hume.ai](https://platform.hume.ai).
  142. 2. Go to **Voice Library → Clone Voice** (or **Add Voice → Upload**).
  143. 3. Upload `rocky-tts/public/RockyVoice-James.wav`, name it `Rocky`, and create it.
  144. 4. Open the new voice and copy its **voice id**.
  145. 5. Paste it into `rocky-tts/.env`:
  146. ```
  147. HUME_VOICE_ID=your-copied-id
  148. ```
  149. 6. Restart the app. The console prints `Voice: cloned (...)` when it's using yours.
  150. **No clone yet?** The app still speaks using a stock Hume voice (`HUME_FALLBACK_VOICE` in `.env`, default "Male English Actor") so nothing 404s — it just won't sound like the real Rocky until you clone.
  151. > Heads up: Hume's API can only *save* a voice from a prior generation, not upload an audio file. Cloning from a recording is a Platform (web) action, which is why this step is done in the browser, not by a script.
  152. ## Phone speaker
  153. Rocky can speak through your phone too. The server broadcasts every utterance to all connected browsers, so the phone is just a second listener.
  154. This uses [Tailscale](https://tailscale.com) to give your phone a private route to the desktop. No public exposure, no port forwarding, no cost.
  155. ### Setup
  156. 1. Install [Tailscale](https://tailscale.com/download) on your desktop and phone. Sign into the same account on both.
  157. 2. Set `HOST=0.0.0.0` in `rocky-tts/.env` so the server accepts connections from the tailnet.
  158. 3. Run `tailscale status` on the desktop and note the MagicDNS name (e.g. `desktop.tailxxxx.ts.net`).
  159. 4. Set `TAILNET_HOST=your-desktop.tailxxxx.ts.net` in `.env` (prints the phone URL on boot).
  160. 5. Proxy HTTPS in front of the server (one time):
  161. ```bash
  162. tailscale serve --bg 3333
  163. ```
  164. 6. Restart the Rocky server (`npm start`). The console prints the phone URL.
  165. 7. On your phone, open the URL and tap **Initialize**.
  166. Rocky now speaks on both devices. Mute whichever you are not using.
  167. ### Notes
  168. - **HTTPS vs HTTP.** `tailscale serve` provides HTTPS with a real cert. If HTTPS certs are not provisioned yet, use the Tailscale IP directly: `http://<tailscale-ip>:3333`. Audio works on HTTP; Wake Lock (screen stays on) requires HTTPS.
  169. - **Wake Lock.** The page requests a screen Wake Lock after you tap Initialize. This keeps the phone screen on while the tab is open and foregrounded. Requires HTTPS (Tailscale serve provides it). If your phone still sleeps, increase the display timeout in your phone settings.
  170. - **Double audio.** Both tabs play slightly out of sync. Mute one with the volume slider, or just don't open the desktop tab.
  171. - **Do not use `tailscale funnel`.** That exposes the server to the public internet. `serve` keeps it inside your tailnet.
  172. ## Configuration
  173. All runtime settings live in `rocky-tts/.env`. Copy `.env.example` to `.env`, edit, then **restart the server** for changes to take effect (`npm start`, or restart Claude Code if you use the `SessionStart` hook).
  174. | Setting | Default | What it does |
  175. |---|---|---|
  176. | `HUME_API_KEY` | — | Your Hume API key. **Required.** Get it at [platform.hume.ai](https://platform.hume.ai). |
  177. | `HUME_VOICE_ID` | — | Your cloned Rocky voice id (see [Voice setup](#voice-setup--clone-your-own-rocky-1-minute-one-time)). Leave unset to use the fallback. |
  178. | `HUME_FALLBACK_VOICE` | `Male English Actor` | Stock Hume voice used until you set `HUME_VOICE_ID`. Any voice name from Hume's Voice Library works. |
  179. | `ROCKY_SPEED` | `1.25` | Speech speed. Higher = faster, lower = slower. See below. |
  180. | `HOST` | `127.0.0.1` | Address the server binds to. Default keeps the API private to your machine. Set to `0.0.0.0` for phone access via Tailscale (see [Phone speaker](#phone-speaker)). |
  181. | `PORT` | `3333` | Port the server listens on. If you change it, update the hook URLs and `ROCKY_TTS_URL` to match. |
  182. | `TAILNET_HOST` | — | Your desktop's Tailscale MagicDNS name. Only used to print the phone URL on boot. See [Phone speaker](#phone-speaker). |
  183. | `HUME_SECRET_KEY` | — | Not used by the app today. Safe to leave as the placeholder. |
  184. > Your `.env` is gitignored — your keys never get committed. Only `.env.example` (placeholders) is in the repo.
  185. ### Speed toggle
  186. Want Rocky faster or slower? Set `ROCKY_SPEED` in `.env`:
  187. ```
  188. ROCKY_SPEED=1.5 # snappy
  189. ROCKY_SPEED=1.25 # default
  190. ROCKY_SPEED=0.9 # slow and deliberate
  191. ```
  192. Keep it within **0.75–1.5** for clean audio — values further out can make Hume's output unstable. Restart the server after changing it.
  193. ### Using a different fallback voice
  194. Before you clone (or if you just want a different stock voice), set `HUME_FALLBACK_VOICE` to any voice name from Hume's Voice Library, e.g. `HUME_FALLBACK_VOICE=Female English Actor`. Ignored once `HUME_VOICE_ID` is set.
  195. ### Deeper tuning (edit `rocky-tts/server.js`)
  196. A few knobs live as constants near the top of `server.js`:
  197. - **`ROCKY_DESCRIPTION`** — the acting directions sent to Hume (`"Alien engineer. Broken English. Deliberate. Warm but strange."`). Tweak Rocky's delivery here; keep it under ~100 characters. Only works on Octave 1 (the version the app uses) — Octave 2 rejects acting directions.
  198. - **`MAX_UTTERANCE_CHARS`** (`4500`) — long replies are split into pieces under this limit so nothing gets cut off (Hume's hard cap is 5000 chars per utterance).
  199. - **`MAX_SPEAK_CHARS`** (`6000`) — overall ceiling on how much of a single reply is spoken, so a runaway response can't generate endless audio. Raise it to read even longer replies in full.
  200. ## Turn on, turn off
  201. Activate the skill, then talk. Whole conversation is Rocky.
  202. Stop any time. Say **"Rocky stop"** or **"normal mode"**. Claude is normal again.
  203. ## It knows your name
  204. Rocky learns your name from the conversation and uses it. Does not know it, Rocky asks first. Rocky does not guess. Rocky does not call you wrong name. That is rude.
  205. ## It stays safe
  206. Broken grammar is fun. Broken grammar can hide danger. So when words must be exact — a warning, a thing that cannot be undone, steps where wrong order breaks the thing — Rocky drops the broken grammar and says that part plain and clear. Then Rocky goes back to Rocky. Code never breaks. Numbers never break.
  207. ## Not for work
  208. Keep Rocky away from client work, real documents, anything where exact wording carries load. Rocky is for fun. Turn him off for the serious thing.
  209. ## Credit
  210. The bundled voice clip (`rocky-tts/public/RockyVoice-James.wav`) is an original recording by the repo author, provided so you can clone your own voice.
  211. Persistence, safety-clarity, and off-switch ideas borrowed from [caveman](https://github.com/JuliusBrussee/caveman) by Julius Brussee — a token-compression skill built on the same "small mouth, big brain" idea.
  212. Rocky is a character created by Andy Weir in *Project Hail Mary*. This is a fan project. Not affiliated with the author or publisher.
  213. ## License
  214. MIT. See [LICENSE](LICENSE).

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.