talkis/README.md

Talkis

Open desktop voice input for people who write in real apps all day.

Read in Russian · Website · Latest release

What Is Talkis?

Talkis is a desktop voice-to-text app built with Tauri, React, TypeScript, and Rust. It stays as a small floating widget, records while you hold a hotkey, transcribes your speech, optionally cleans the text with an LLM, and pastes the final result into the app you were using.

It is designed for practical daily work: IDEs, chats, notes, CRM fields, email, files, and meeting transcripts.

Highlights

• Dictate into any active text field with a global hotkey.
• Use locked recording mode for longer speech without holding the keys.
• Paste cleaned text automatically after transcription.
• Choose cloud mode, your own API key, or local STT models.
• Transcribe audio and video files from the Files tab or by dropping files onto the widget.
• Record macOS calls with separate microphone and system-audio tracks.
• Keep local history for voice recordings and file transcriptions.
• Run managed local STT through one native transcribe.cpp runtime for Whisper, Qwen ASR, NVIDIA Parakeet, plus speaker diarization.
• Build native bundles for macOS, Windows, and Linux.

Latest Changes

v0.3.7

• Migrated managed local file transcription to a unified native transcribe.cpp runtime for Whisper, Qwen ASR, and NVIDIA Parakeet.
• Removed the old Qwen/Parakeet MLX/Python sidecars from the desktop bundle and release build.
• Fixed local STT settings migration so old Qwen/Parakeet endpoints move to http://127.0.0.1:8000 and do not require an API key.
• Fixed selecting a local transcription model so it no longer clears the selected text model used for summarization.

v0.3.6

• Fixed permissions onboarding recovery for existing installs so updates do not reopen the full permissions screen when required macOS access is already granted.
• Switched the app icon set from Lucide to Phosphor through a local icon facade for softer, more consistent product UI icons.
• Added a macOS Vite/esbuild runner workaround for development and release builds from external drives.
• Kept local STT failures separate from API-key authentication errors when a local model is selected.

v0.3.5

• Fixed local STT mode so managed localhost runtimes are called without a stale API bearer token and no longer show an API-key error for local runtime failures.
• Improved widget notice layout so the status icon stays visually centered next to long messages.
• Prevented call-capture startup errors from resetting the completed permissions onboarding state after restart.

v0.3.4

• Fixed repeated permission prompts after restarting macOS: startup checks no longer trigger a microphone request, and Accessibility is not reset before re-requesting access.
• Updated the transcription statistics card to show words today, words this month, and words per minute instead of the less useful all-time words metric.

Demo

The repository includes the same GIF demos used on the Talkis website.

Demo	What it shows
Dictating code	A short development request inserted into an editor
Dictating an email	Business-style speech-to-email flow
Dictating a note	Everyday notes and task capture
Recording a call	Separate call-recording flow from the widget
Transcribing a file	Audio/video file transcription
Choosing models	Local models and own API configuration

Show more demos inline

Email Dictation

Notes

Call Recording

File Transcription

Local Models And API Keys

How It Works

1. Focus the text field where you want the result to appear.
2. Hold Shift + Command + Space on macOS.
3. Speak naturally.
4. Release the hotkey.
5. Talkis transcribes, cleans, and pastes the text.

The hotkey, microphone, language, model source, cleanup style, and app appearance are configurable in Settings.

Access Modes

Talkis Cloud

Sign in to Talkis Cloud and use transcription without managing API keys. Requests go through proxy.talkis.ru.

Own API Key

Use an OpenAI-compatible STT endpoint and a separate LLM endpoint for text cleanup. The Models tab also contains API adapter cards for supported providers.

Supported STT model names include:

• whisper-1
• gpt-4o-transcribe
• gpt-4o-mini-transcribe

Local Models

Install and run Talkis-managed local models from Settings. Local mode is transcription-only unless you also configure a separate LLM endpoint.

Managed local runtimes:

• Whisper, NVIDIA Parakeet GGUF, and Qwen ASR GGUF through the unified transcribe.cpp runtime, default endpoint http://127.0.0.1:8000
• Speaker diarization, default endpoint http://127.0.0.1:8003

If a default port is busy, Talkis starts the managed runtime on a fallback port and saves the actual endpoint in settings.

Installation

Download the latest build from GitHub Releases:

• macOS DMG
• Windows x64 installer
• Linux x64 AppImage

If your OS blocks the first launch

Talkis is currently distributed without paid code signing, so Gatekeeper (macOS) and SmartScreen (Windows) show an "unverified app" warning. This is not malware: the source is open (AGPL-3.0) and the builds are produced by the public GitHub Actions workflow in this repo. How to open it:

macOS — "Apple could not verify Talkis is free of malware":

1. In the dialog click Done (not "Move to Trash").
2. Open System Settings → Privacy & Security, scroll down to "Talkis was blocked…" and click Open Anyway.
3. Confirm with your password or Touch ID and click Open again.

Or, in one command in Terminal (after moving it to Applications):

xattr -dr com.apple.quarantine /Applications/Talkis.app

Windows — the blue "Windows protected your PC" dialog:

1. Click More info.
2. Click Run anyway.

On first launch, grant the permissions Talkis needs:

• Microphone access for recording.
• Accessibility permission on macOS for automatic paste.
• Screen and System Audio Recording permission on macOS for call recording.

After permissions are granted, Talkis stores the completed onboarding state and does not reopen native permission prompts on every launch. If an OS permission is reset or denied later, Talkis asks again only when that access is needed.

File Transcription

The Files tab supports audio and video transcription up to 8 GB. Files are processed through a native path-based pipeline, so large files do not need to be loaded into WebView memory.

Talkis uses the bundled ffmpeg sidecar for video, unsupported audio formats, chunking, and diarization preparation. Ready 16 kHz mono PCM WAV files can skip conversion for local STT.

Speaker diarization is available through Talkis Cloud or through local Whisper plus the local diarization runtime, depending on the selected access mode.

Call Recording

Call recording captures two tracks:

• You from the microphone.
• Call from system audio.

System-audio capture is implemented with Core Audio on macOS, WASAPI loopback on Windows, and PipeWire monitor streams on Linux. Linux requires a running PipeWire daemon with an active output device.

Privacy

• In cloud mode, requests go through proxy.talkis.ru.
• In own-key mode, requests go directly to the endpoints you configure.
• In local mode, transcription stays on your machine.
• API keys and device tokens are stored locally in app settings.
• Voice history and file transcription history are stored locally.
• Talkis does not keep audio on its own servers beyond the API call.

Troubleshooting

• Nothing is pasted: check macOS System Settings -> Privacy & Security -> Accessibility and make sure Talkis is enabled.
• Transcription contains unexpected foreign characters: choose a fixed recognition language such as ru or en instead of auto.
• Local STT returns model errors: open Модели -> Локально, make sure the model is installed and selected, then reinstall it if the runtime reports missing files.
• Call recording cannot start: grant Microphone and the OS system-audio permission, then start the call recording again. On Linux, also make sure PipeWire is running and an output device is active.
• Need deeper diagnostics: open ~/.talkis/talkis.log or run bun run logs during development.

Development

Requirements:

• Bun 1.2.x
• Rust stable
• Tauri v2 system dependencies

Install dependencies and start the app:

bun install
bun run prepare:sidecars
bun run tauri dev

Useful commands:

bunx tsc --noEmit
cargo check --manifest-path src-tauri/Cargo.toml
bun run check:release
bun run tauri build
bun run build:release:macos
bun run logs

On Ubuntu/Debian, install native Tauri and sidecar build dependencies first:

sudo apt update
sudo apt install -y libwebkit2gtk-4.1-dev libayatana-appindicator3-dev libxdo-dev libasound2-dev librsvg2-dev patchelf clang libclang-dev cmake

Project Structure

src/                  React and TypeScript frontend
src/windows/widget/   Floating widget window
src/windows/settings/ Settings window and tabs
src/lib/              Store, auth, permissions, logging, shared clients
src-tauri/src/        Rust backend, Tauri commands, audio, paste, STT
src-tauri/icons/      App icons
docs/                 Release docs, audio rules, demo media
scripts/              Release and sidecar preparation scripts

For audio, transcription, local STT, file transcription, or call-capture changes, read docs/audio-pipeline-principles.md before editing code.

Tech Stack

• Tauri v2
• React 19
• TypeScript
• Rust
• cpal native microphone recording
• OpenAI-compatible STT and LLM APIs
• Managed local STT sidecars
• Bundled ffmpeg sidecar

Contributing

Issues and pull requests are welcome. Before changing audio behavior, read the audio pipeline document and keep enough logging to debug recorder stats, ffmpeg timing, STT endpoint selection, chunk progress, and call-capture levels.

Project conventions:

• UI text is Russian.
• Code and comments are English.
• Package manager is Bun.
• Settings are persisted immediately after change.
• Release workflow is documented in rules/release.rule.md.

License

Talkis is licensed under the GNU Affero General Public License v3.0 or later (AGPL-3.0-or-later).

This license keeps the desktop app open-source and also requires source availability for modified versions that are offered to users over a network, which matters for the Talkis Cloud/API companion surface.