TalkTo - Local Voice Transcription

Fast, private, and easy to use - like WisprFlow but 100% local and FOSS.

A lightweight desktop application for fully local voice-to-text transcription using OpenAI's Whisper models. Built with Tauri, React, and FastAPI. No internet required after setup, no subscriptions, unlimited usage.

Features

100% Local & Private: All processing happens on your machine
Multiple Model Options: Choose from tiny (75MB) to distil-large-v3 (1.5GB)
Low RAM Usage: Uses faster-whisper with int8 quantization for minimal memory
Global Hotkey: Toggle recording from anywhere (default: Ctrl+Alt+R)
- X11, Windows, macOS: Native support
- Wayland: Requires compositor-level setup - see WAYLAND.md
Auto-Copy to Clipboard: Transcribed text automatically copied
Simple Interface: Click record button or use global hotkey
Multi-language: Supports 100+ languages via Whisper
Voice Activity Detection: Automatically filters out silence
Modern UI: Clean, responsive interface built with React and Tailwind CSS

Recommended Model

small (466MB) - Excellent balance of speed, accuracy, and resource usage. Best for most users.

Installation

From Release Packages (Linux)

Download the latest .deb or .rpm from Releases:

Debian/Ubuntu:

sudo dpkg -i TalkTo_*.deb

Fedora/RHEL:

sudo rpm -i TalkTo-*.rpm

The backend Python environment is bundled - no Python installation needed!

From Source

Prerequisites

Node.js 18+ and pnpm (npm install -g pnpm)
Python 3.8+ with venv
Rust 1.70+ (via rustup)

System dependencies (Linux):

# Debian/Ubuntu
sudo apt install libwebkit2gtk-4.1-dev libgtk-3-dev libayatana-appindicator3-dev librsvg2-dev

# Fedora
sudo dnf install webkit2gtk4.1-devel gtk3-devel libappindicator-gtk3-devel librsvg2-devel

# Arch
sudo pacman -S webkit2gtk-4.1 gtk3 libappindicator-gtk3 librsvg

1. Clone the repository

git clone https://github.com/yourusername/talkto.git
cd talkto

2. Install frontend dependencies

pnpm install

3. Set up Python backend

python3 -m venv venv
source venv/bin/activate  # On Linux/Mac
# OR
venv\Scripts\activate     # On Windows

pip install -r backend/requirements.txt

4. Start development servers

Terminal 1 (Backend):

source venv/bin/activate
python -m uvicorn backend.main:app --host 127.0.0.1 --port 8765 --reload

Terminal 2 (Frontend + Tauri):

pnpm tauri:dev

The app will open automatically. Backend must be running on port 8765.

Usage

Start the app: Launch TalkTo from your applications menu or run pnpm tauri:dev
Select a model: Choose from the dropdown (recommended: small)
Load model: Click "Load" - first run will download from HuggingFace (~500MB)
Record audio:
- Click the microphone button, or
- Press your global hotkey (Ctrl+Alt+R by default)
Transcribe: Click stop or press hotkey again - text auto-copies to clipboard
Paste anywhere: Your transcript is ready to paste (Ctrl+V)

Settings

Global Hotkey: Customize your recording keybinding (e.g., Ctrl+Shift+Space)
Model Selection: Switch between models for speed/accuracy tradeoffs
Device Selection: Choose your microphone input

Model Comparison

Model	Size	RAM	Speed	Accuracy	Best For
tiny	75 MB	~1GB	Very Fast	Low	Testing, low-resource devices
base	145 MB	~1GB	Fast	Good	Quick tasks
small	466 MB	~2GB	Balanced	Very Good	RECOMMENDED - Best balance
medium	1.5 GB	~5GB	Slower	Excellent	High accuracy needed
distil-large-v3	1.5 GB	~5GB	Very Fast	Excellent	6x faster than large-v3
large-v3	3 GB	~10GB	Slow	Best	Maximum accuracy

Add .en suffix for English-only models (e.g., small.en) for better efficiency.

Architecture

TalkTo uses a hybrid architecture:

Frontend: React + TypeScript + Vite + Tailwind CSS
Desktop Shell: Tauri v2 (Rust) - provides native desktop integration
Backend: FastAPI (Python) + faster-whisper - handles transcription

The frontend communicates with the backend via HTTP on localhost:8765. This design keeps the UI responsive while heavy transcription runs in a separate process.

Key files:

src/App.tsx - Main UI and global hotkey logic
backend/main.py - FastAPI endpoints and CORS config
backend/whisper_engine.py - Whisper model wrapper
src-tauri/src/lib.rs - Tauri app setup

System Requirements

Minimum:

CPU: 2-core processor
RAM: 2GB (for tiny/base models)
Storage: 500MB - 4GB (depending on model)
OS: Windows 10+, macOS 10.15+, or Linux (X11/Wayland)

Recommended:

CPU: 4-core processor
RAM: 4GB (for small model)
GPU: Optional NVIDIA GPU with CUDA for faster transcription

Privacy

No internet required after initial model download
No data sent anywhere - everything runs locally
No telemetry or tracking
Models cached in ~/.cache/huggingface/hub/

Global Hotkeys on Wayland

⚠️ Important: Tauri's global-shortcut plugin doesn't work natively on Wayland due to security restrictions in the Wayland protocol.

We provide a compositor-level workaround that works perfectly! See WAYLAND.md for setup instructions for:

Sway / i3
Hyprland
KDE Plasma
GNOME
Wayfire
River
niri

Quick setup: Configure your compositor to run curl -X POST http://localhost:8765/toggle-recording on your desired key combination.

Building Distribution Packages

Linux (DEB/RPM)

1. Bundle the backend (creates standalone Python executable):

source venv/bin/activate
pyinstaller backend.spec

This creates backend-bundle/ with a standalone backend executable.

2. Build Tauri packages:

pnpm tauri:build

Outputs:

src-tauri/target/release/bundle/deb/TalkTo_*.deb
src-tauri/target/release/bundle/rpm/TalkTo-*.rpm

The bundled packages include both the Tauri app and the Python backend - users don't need Python installed!

Troubleshooting

Backend won't start

Check port availability:

# Kill existing backend if port 8765 is busy
lsof -ti:8765 | xargs kill -9

Then restart: python -m uvicorn backend.main:app --host 127.0.0.1 --port 8765

"Backend not connected"

Ensure backend is running on port 8765
Check firewall isn't blocking localhost connections
View backend logs in terminal for errors

Empty transcriptions

Audio too short: Record at least 1-2 seconds of speech
Wrong microphone: Check Settings → Device dropdown
Model not loaded: Load a model first before recording

Global hotkey not working

X11/Windows/macOS: Check console for "Global shortcut registered" message
- Try a different key combination if current one is taken
- Restart app after changing hotkey
Wayland: See WAYLAND.md for compositor setup

Low transcription accuracy

Try a larger model (distil-large-v3 or large-v3)
Use English-only model (e.g., small.en) for English speech
Record in a quiet environment
Speak clearly and at moderate pace

CUDA/GPU not working

Ensure NVIDIA drivers are installed
Install CUDA-enabled version of faster-whisper (backend will auto-detect)
Otherwise, CPU mode works fine - just slower

Model download fails

Check internet connection
Models download from HuggingFace on first use
Large models (1-3GB) may take several minutes

Development

Project Structure

/backend/              # FastAPI backend
  main.py              # API endpoints (health, transcribe, models)
  whisper_engine.py    # Whisper model loading and inference
  audio_handler.py     # Audio file processing
  models.py            # Pydantic models

/src/                  # React frontend
  App.tsx              # Main component with global hotkey logic
  /components/         # UI components
  /hooks/
    useAudioRecorder.ts  # Microphone recording hook
  /lib/
    api.ts             # Backend API client

/src-tauri/            # Tauri desktop app
  tauri.conf.json      # App configuration and bundling
  Cargo.toml           # Rust dependencies
  src/lib.rs           # Tauri setup and permissions

backend.spec           # PyInstaller config for bundling backend
run_backend.py         # Backend entry point for PyInstaller

Testing

Backend API:

# Health check
curl http://localhost:8765/health

# Model status
curl http://localhost:8765/models/status

# Load a model
curl -X POST http://localhost:8765/models/load \
  -H "Content-Type: application/json" \
  -d '{"model_name": "tiny"}'

Backend unit tests:

python backend/test_backend.py

Contributing

Contributions welcome! Please:

Fork the repository
Create a feature branch (git checkout -b feature/amazing-feature)
Commit your changes (git commit -m 'Add amazing feature')
Push to the branch (git push origin feature/amazing-feature)
Open a Pull Request

See CLAUDE.md for detailed development guidelines.

Comparison to WisprFlow

Feature	TalkTo	WisprFlow
Price	Free	$12/month
Usage Limit	Unlimited	2,000 words/week (free)
Privacy	100% local	Cloud-based
Platform	Windows/Mac/Linux	Windows/Mac/iOS
Open Source	Yes	No
Offline	Yes	No
Transcription Engine	Whisper (faster-whisper)	Whisper (cloud)

Roadmap

License

MIT License - See LICENSE file for details

Credits

Built with Tauri for native desktop integration
faster-whisper for efficient inference
OpenAI Whisper models for transcription
Inspired by WisprFlow

Support

Issues: GitHub Issues
Discussions: GitHub Discussions
Documentation: See CLAUDE.md and WAYLAND.md

Made with ❤️ for privacy-conscious users who want local, unlimited voice transcription.

Name		Name	Last commit message	Last commit date
backend		backend
src-tauri		src-tauri
src		src
.gitignore		.gitignore
.mcp.json		.mcp.json
ARCHITECTURE.md		ARCHITECTURE.md
BACKEND_COMPLETE.md		BACKEND_COMPLETE.md
CLAUDE.md		CLAUDE.md
INSTALL_DEPS.sh		INSTALL_DEPS.sh
README.md		README.md
WAYLAND.md		WAYLAND.md
components.json		components.json
index.html		index.html
package.json		package.json
postcss.config.js		postcss.config.js
requirements.txt		requirements.txt
start.sh		start.sh
stop.sh		stop.sh
tailwind.config.js		tailwind.config.js
talkto.py		talkto.py
toggle-recording.sh		toggle-recording.sh
tsconfig.json		tsconfig.json
tsconfig.node.json		tsconfig.node.json
vite.config.ts		vite.config.ts

Latest commit

History

Folders and files

Repository files navigation