I type for a living. So do you, probably. And somewhere along the way we all
started typing more — not to write code, but to explain what we want the code
to do. Long, careful prompts. Paragraphs that are really just me talking to a
machine that only listens through a keyboard.
One night I caught myself: I had a perfect sentence in my head, and I was
hunting for the keys to spell it out one letter at a time. That felt absurd.
I own a microphone. My computer owns a microphone. Why am I still typing?
VoxTerm started as a question — what if the terminal just listened? — and
became a genuine side-hustle-shaped product: a premium desktop workspace for
real operating-system shells where you dictate a prompt, it gets cleaned up by
an open-weight model, and it lands in your shell ready to run. You still press
Enter. That part matters.
What I Built
VoxTerm is a desktop terminal workspace (Electron + React + xterm.js) built
around one honest idea: every button does the thing it says, or it tells you why
it can't.
It is a real terminal first — genuine node-pty sessions running bash, zsh,
fish, anything on your $PATH, with correct input/output, resize, Unicode and
cleanup. On top of that foundation it adds the things a developer actually
wants when they're deep in a session:
- 🎙 Dictation into the shell. Hold a hotkey, speak, release. Your words are transcribed and typed into the active terminal. Never auto-executed — you review and hit Enter.
- 🤖 Prompt cleanup with open-weight Gemma. The raw transcript gets rewritten by a fallback chain — local Ollama first, then Google's hosted Gemma — so "make it list the big files in downloads" becomes a crisp shell command.
- 🔒 A real privacy switch. Local-only mode refuses every cloud request at the service layer. Pair it with Ollama and nothing ever leaves the machine.
-
🖧 Attach to sessions you already have. Live discovery of tmux/screen
sessions running outside the app, with exact
$N-id targeting and honest caveats when a session is shared. - 🔊 Spoken announcements. ElevenLabs text-to-speech for events the app can actually confirm — a build error, a session exit, an agent milestone.
- 🧩 Agent-agnostic. OpenCode, Claude Code, Codex CLI, Gemini CLI, Aider — detected by what's genuinely installed, nothing fabricated.
Who would pay for it? This is aimed at the professional who lives in a
terminal and bills by the hour — backend and platform engineers, DevOps and SRE
folks, data engineers, and the fast-growing crowd of developers who now drive
coding agents from the CLI all day. For them, typing is the last slow part of
the loop. A tool that removes friction without removing control is worth
money.
The problem it solves, in one line: it turns the most tedious part of
working with AI — writing the prompt — into the most natural thing a human does:
talking. And it does it without ever taking the wheel away from the driver.
The Terminals view. Real shells, real tabs, and a dictation that just landed as
editable text — not an executed command.
Code
The whole thing is open source under MIT:
maisamabbas0323
/
voxterm
VoxTerm 'hacktoberfest week#2 challange' is a cross-platform voice-controlled terminal for developers, enabling natural multilingual voice commands for OpenCode, Claude Code, Codex, and other coding agents with offline speech recognition and intelligent prompt refinement. Built with Electron.js for Linux, Windows, and macOS.
VoxTerm
Type less. Talk more. Ship code.
A premium, voice-ready terminal workspace for developers — real operating-system shells, speech-to-text dictation, agent-agnostic CLI sessions and an explicit honest human-in-the-loop workflow.
Table of contents
- Why VoxTerm
- Feature highlights
- Platform support
- Quick start
- Configuration
- Using VoxTerm
- Keyboard shortcuts
- Settings reference
- Security & privacy model
- Architecture
- Project structure
- Tech stack
- Testing & verification
- Known limitations
- Roadmap
- Contributing
- License
- Author
Why VoxTerm
Most "AI terminals" are a chat box bolted onto a shell, wrapped in marketing. VoxTerm is the opposite: a genuinely good terminal first, with voice and local models added where they actually help — and every control either does the thing it claims or tells you exactly why it can't.
Concretely:
- Real shells,…
If the embed doesn't render: github.com/maisamabbas0323/voxterm
A quick tour of what's inside:
| Layer | What it does |
|---|---|
src/main/terminals |
Owns every node-pty process — never the renderer |
src/main/voice |
ElevenLabs speech-to-text + the global push-to-talk hotkey |
src/main/prompts |
The Ollama → Google Gemma fallback chain and its instructions |
src/main/external |
tmux/screen discovery and precise attach targeting |
src/shared |
Zod schemas + the typed IPC contract, shared by both sides |
How I Built It
The stack is intentionally boring where it should be, and interesting only where
it earns it.
The shell is sacred. VoxTerm is a real terminal first. Every tab is a
node-pty process owned entirely by the Electron main process; the renderer
just sends keystrokes and receives output over a typed, Zod-validated IPC
bridge. The renderer is sandboxed with context isolation and no Node access, so
a bug (or a malicious page) can't reach your filesystem through the UI. This
isn't paranoia — it's the difference between a tool you trust with your shells
and one you don't.
The AI is open-weight and yours to run. For prompt cleanup I didn't want to
hard-wire one company's API into the core loop. So VoxTerm calls a fallback
chain:
- Ollama first — a fully local, open-weight Gemma model on your own machine. This is the default the product is designed around, because it's the one that makes the privacy promise real: nothing leaves your computer.
- Google AI Studio's hosted Gemma as the fallback for machines that can't run a local model — reached with your own API key against the official endpoint, with no configurable base URL to get wrong.
That ordering is the whole point. It means the "free and private" path is the
primary path, and the cloud is the convenience path — not the other way
around. Speech-to-text and spoken announcements go through ElevenLabs because
good real-time transcription and natural TTS are genuinely hard to match with a
small local model today, and the app is upfront in the UI that dictation audio is
sent to that service.
The engineering rule I refused to break: no fake buttons, no invented
statistics, no placeholder sessions. If a feature isn't wired up, it's disabled
and labelled. Provider status is a real network probe. "Detected tooling" is a
real filesystem lookup with the resolved path and version. The activity log
stores metadata only — never your terminal output, never env vars, never secrets.
Honesty became an architecture decision, not a marketing line.
Settings shows real provider reachability and a one-switch local-only mode. The
voice controls live here too — no separate "AI panel" pretending to be useful.
A few of the tools that made this buildable: Electron 44, React 19,
xterm.js 6, node-pty, Zod 4, electron-vite / Vite 7,
Vitest 5, and lucide-react for every icon (SVG only — no emoji avatars,
no decorative AI sparkle). It's verified with 105 unit tests, a headless
Chrome-DevTools-Protocol UI smoke test, and real calls against both providers.
Why Does Open Innovation Matter?
VoxTerm would be a worse product if it had been built around a single closed API.
Here's concretely why.
Open weights made the privacy promise possible. The entire premise —
"your voice, your prompts, your machine" — only works because I can run a
capable model like Gemma locally through Ollama. A closed, cloud-only model
would have forced every prompt through someone else's servers, and "local-only
mode" would have been a lie I couldn't tell. Open-weight models turned a privacy
feature into a privacy fact.
Open source let me build a terminal I actually trust. node-pty, xterm.js,
Electron, Zod, Vite — I read the code, patched around edge cases, and shipped
because thousands of people already solved the hard parts in public. That's the
quiet superpower of open innovation: nobody has to rebuild a PTY from scratch to
make something new on top of it.
It keeps the exit door open. Because the provider layer is a chain and not a
contract, you can swap Ollama for a different local runner, add another hosted
model, or run entirely offline — without asking anyone's permission or waiting
for a pricing page to change. That's what open innovation buys you: the ability
to keep building when the ground shifts underneath you.
And honestly? It's just nicer. Building in the open meant every design choice
was a conversation with how real tools behave, not a negotiation with a vendor's
roadmap.
My First User
The first person to actually open VoxTerm wasn't a customer — it was a friend who
lives in tmux and has opinions about everything. I handed them the build, watched
them attach to a session they already had running, dictate one command, and go
quiet for a second.
Then: "Okay, that was faster than typing it. That's annoying. I want it."
They haven't paid me — this is still a side project finding its feet, and I'd
rather say that plainly than invent a fake invoice. But "I want it" from someone
who is not impressed by anything is the signal I actually trust. The next step is
turning that into the boring, unglamorous part of a side hustle: a pricing page,
a signed build, and a handful of real users who'll tell me what's still wrong.
Prize Categories
Given what VoxTerm is built on and how it's verified, I'm entering the categories
that genuinely apply — I'll confirm the exact list from the challenge page before
publishing:
- Best Use of Open-Source AI — the core loop runs on open-weight Gemma via a local Ollama first, with a hosted fallback.
- Best Use of ElevenLabs — ElevenLabs does real work in two places, not a decorative bow: speech-to-text turns a held hotkey into a transcript that lands straight in the shell, and text-to-speech speaks only the events a developer actually cares about (a crash, a finished agent step) — never your terminal output, never your secrets. Both paths are privacy-gated, clearly labelled in the UI, and wired so the local/open-weight model stays the default.
- Best Developer Tool — a real desktop terminal for professional workflows.
- Best Side Hustle — built to be something people would actually pay for, not a demo.
What's Next
VoxTerm isn't a weekend sketch that stops at the demo. The roadmap is the same
list a paying user would care about:
- Per-agent adapters so the terminal can understand agent events instead of just displaying them.
- Word-timestamp highlighting in the dictation flow, so you can see what the model thought you said.
- A signed, packaged release and a real pricing model.
- macOS and Windows follow behind Linux — I'd rather ship one platform well than three badly.
If you're the kind of person who types Ctrl+R and then apologises to your shell
— give it a try, break it, and tell me where it hurts. That's the only way a side
hustle becomes something worth paying for.
Repo: https://github.com/maisamabbas0323/voxterm
License: MIT
Built with: Electron, React, xterm.js, node-pty, Zod, and open-weight Gemma
via Ollama.
Type less. Talk more. Ship code.
Top comments (0)