Brasle

Speech you can feel, words you can say. Brasle is an AI interpreter which lives in a glove that gives people who are deaf AND blind the ability to have a two way conversations.

Comment

Inspiration

Brasle (say it like "braille") puts an interpreter into something you can wear.

For someone who can't see or hear, a conversation usually needs a human interpreter beside them: a Support Service Provider or tactile interpreter who listens, decides what matters, and passes it into their hands. Interpreters are scarce and can't be there all the time.

Brasle started as a one-way glove that buzzed every spoken letter as braille. It worked, but it exposed the real problem: each letter takes about a second to feel, so the glove reads at ~10 words per minute while people talk at ~150. After one sentence the wearer is a minute behind, and they had no way to answer.

What it does

Brasle makes it a two-way conversation:

Listening: speech → fingertips. A mic on the Raspberry Pi hears the room, and speech recognition runs on the Pi itself. For every sentence, an AI interpreter (Claude Haiku 5.5) decides whether to send it, skip it, or interrupt with it. Then it rewrites the sentence into the fewest letters that keep the meaning and buzzes it as braille on three rings. "Hey, would you like to grab some coffee later this afternoon, maybe around three?" takes 79 seconds to buzz letter by letter; "coffee at three?" takes 16. Danger ("watch out!") and the wearer's name are urgent: a distinct pulse cuts the line. Filler and background chatter are skipped.

Talking: fingertips → speech. The user taps Morse anywhere on their iPhone screen (tap = dot, hold = dash, swipe right = send, swipe left = delete) and feels every tap confirmed on the glove. Claude fixes mistaps and expands short replies using the conversation so far ("Y 3" becomes "Yes, three works for me") without adding meaning the user didn't tap. ElevenLabs speaks it out loud, giving the user a voice in the room. The Pi's mic mutes itself while the phone talks, so the user's own words are never buzzed back to them.

Asking: the live web. Swipe up instead of right, and the message goes to the agent instead of the room. Claude decides whether the question needs the web, searches if it does, and sends the answer back as a few words of braille.

Nothing hidden. The AI speaks for someone who can't check its work by looking, so every decision appears on a live dashboard: what was said, what was buzzed, why, and the seconds saved.

Always works. Audio never leaves the Pi; only text goes to the cloud. With no internet, the glove still buzzes every word letter by letter, and the phone uses its built-in voice.

How we built it

  • Hardware: Raspberry Pi 5, USB microphone, 3 vibration discs on GPIO 26/19/13, each driven through an NPN transistor with a flyback diode, on a glove. A 6-dot braille cell is sent as two pulses: the left column (dots 1-3), then the right (dots 4-6).
  • Glove software (Python): gpiozero + lgpio for the Pi 5's new RP1 GPIO chip, and a single haptics thread with a priority queue, so urgent messages interrupt between letters, never mid-letter.
  • Phone app: a web app served directly by the Pi (Flask + plain HTML/JS). Open it in Safari and Add to Home Screen; no App Store needed. The phone and Pi talk over the iPhone's Personal Hotspot, and all API keys stay on the Pi.
  • Four kinds of AI on one wearable:
    • Edge AI: Vosk speech recognition on the Pi, so audio never leaves the device.
    • Language: Claude Haiku 5.5 as the interpreter. For every sentence it returns a structured decision: send, skip or urgent, the shortened message, and a reason. We chose Haiku for speed: on a glove, every second of delay is a second the wearer falls behind.
    • Agentic search: Claude's web search tool, which the model calls only when a question needs it.
    • Generative voice: ElevenLabs text-to-speech, with the phone's built-in voice as a fallback.
    • Every AI call has a timeout and a fallback, so a failed request never cuts the user off.
  • Built to demo reliably: it starts automatically on power-up (systemd) and buzzes a "ready" sweep. A --doctor command checks GPIO, rings, mic, model and network with PASS/FAIL, and automated tests run without any hardware.
  • Built on our earlier project: SixSense (Hack Dearborn 5) was a one-way, letter-by-letter glove. New this weekend as Brasle: the two-way conversation, the AI interpreter, the iPhone Morse app, Pi 5 support, priority haptics, the live dashboard and the tests. These are the commits from "Part 1" onward in the repo.

Challenges we ran into

  • Bandwidth. Touch is ~14× slower than speech. Buzzing faster makes letters unreadable, so the answer had to be sending fewer letters, which is why we built the AI interpreter.
  • Latency. The AI sits between a person talking and the wearer feeling it, so a slow answer is a wrong answer. We use a small, fast model, short timeouts, and plain braille as the fallback when the AI is slow.
  • 6 dots, 3 rings. We send each braille cell as two column pulses.
  • iPhone Safari limits. Web pages can't vibrate on iPhone, so every tap is confirmed on the glove instead. Audio only plays after the first touch. The mic needs HTTPS, so the microphone stays on the Pi.
  • The echo loop. The Pi's mic heard the phone speaking the user's reply and buzzed it back to them. The phone now mutes the mic while it talks, with a 20-second safety unmute.
  • Raspberry Pi 5. Its new RP1 chip breaks the classic RPi.GPIO library, so we moved to lgpio.
  • Noisy rooms. In a crowded hall, the mic picks up everyone. The AI interpreter skips background chatter and fragments that aren't worth the wearer's time, so only real messages reach the glove.

Accomplishments that we're proud of

  • A full conversation between a hearing person and a deafblind person, where the deafblind user never needs to see a screen or hear a sound.
  • Cutting a 79-second message to 16 seconds without losing its meaning.
  • Plug it in and it's ready: no keyboard, monitor or app install.

What we learned

  • Good interpreters don't transcribe; they summarize and prioritize. The AI's job is to do what a good interpreter does.
  • When every letter costs a second, design is about bandwidth, not features. A small, fast model beats a big one when the user feels every second.
  • How much you can build for iPhone without the App Store, and where the limits are.

What's next for Brasle

  • Test with DeafBlind people and interpreters, and tune timing to real braille readers. We haven't done this yet, and it's the most important next step.
  • Braille typing on the phone instead of Morse (like iPhone's built-in Braille Screen Input), so users read and write in one code.
  • Six rings, to show a whole braille cell at once and halve the time per letter.
  • Phone as the brain, glove as a tiny Bluetooth device with a battery in a 3D-printed housing (we've already modeled it).
  • Contracted (Grade 2) braille and more languages.

Built With

Share this project:

Updates

Submission history