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 and text LLM models.
• Translate system audio in real time through Talkis Cloud or a verified Realtime API connection, with optional spoken translation on macOS.
• Translate selected text with a separate configurable global hotkey.
• Transcribe audio and video files from the Files tab or by dropping files onto the widget.
• Record calls with separate microphone and system-audio tracks on macOS, Windows, and Linux.
• Keep local history for voice recordings, file transcriptions, calls, and live translations.
• Run managed local STT through one native transcribe.cpp runtime for Whisper, GigaAM, Qwen ASR, NVIDIA Parakeet, plus local text summaries through a managed GGUF LLM runtime.
• Build native bundles for macOS, Windows, and Linux.

Latest Changes

v0.4.3

• Restored the standard compact hotkey field in Settings, matching the selected-text translator control, while keeping the large live keycap visualization exclusive to onboarding.

v0.4.2

• Added a guided first-run flow that grants permissions, downloads and activates a local STT model, and verifies dictation with the configured global hotkey before setup completes.
• Unified dictation hotkey capture logic across onboarding and Settings, while keeping live key previews in onboarding, apply-without-restart behavior, and conflict handling.
• Reused one local-model card pattern across onboarding and Settings, and added a way to deselect the active local text model without deleting its downloaded file.
• Added managed OPUS-MT English-to-Russian translation, reverse-pair fallback selection, and removal of model reasoning blocks from selected-text translation results.
• Hardened microphone routing for voice and call capture, prevented batch-only local STT models from inheriting API streaming capability, and fixed onboarding when an empty recording produces no transcript.

v0.4.1

• Added GigaAM v3 E2E RNNT as a managed local Russian speech-recognition model, with short file-transcription chunks matched to the model's 25-second window.
• Fixed local selected-text translation dropping everything after the first sentence by translating multi-sentence input as a checked CTranslate2 batch.
• Improved local model installation with automatic retries for transient Hugging Face transport failures and stable installed-state UI while the local runtime refreshes.
• Added live call transcription directly in the Transcription result view while separate microphone and system-audio tracks continue to be saved for recovery and final refinement.
• Added a persistent desktop system tray with explicit Open Talkis and Quit actions; Quit also terminates managed local sidecar processes.
• Added a native Windows release gate that verifies the main application and every bundled sidecar as x86-64 PE executables, plus a published SHA-256 checksum for the stable Windows installer.

v0.4.0

• Added synchronous system-audio translation through Talkis Cloud or verified OpenAI/Gemini Realtime API adapters; local models remain available for the rest of the app, while live translation requires Cloud or API.
• Added optional translated voice playback on macOS, with Talkis audio excluded from capture and the original source ducked to prevent feedback loops.
• Added realtime streaming dictation for supported local and API STT models, including live partial text and a batch fallback for the final result.
• Reworked dictation and selected-text hotkey capture into one release-on-complete transaction with conflict checks, rollback, stale-request protection, and runtime registration without restart.
• Improved the floating text overlay: wider streaming layout, compact speaker turns, dark-theme support, drag-to-move, immediate replacement by a new request, and automatic dismissal ten seconds after terminal results.
• Fixed selected-text translation, permission recovery after relaunch, widget edge clipping, history action menus near the viewport edge, live-translation audio playback, and persisted widget/streaming settings.
• File transcripts now present the first detected speaker as You and the others as Guest N; stable inline renaming updates every segment without moving the caret.
• Call history now keeps and synchronously plays separate microphone and system-audio tracks so both sides of a conversation remain audible.
• The experimental development chat now searches local history with general lexical and offline-semantic ranking, while a compatible embedding backend can optionally improve recall.
• Added a stable signed macOS development app runner so TCC permissions survive local rebuilds when an Apple Development identity is available.

v0.3.12

• Fixed the Windows frontend release build by invoking Vite through its package JavaScript entrypoint instead of the platform-specific .cmd shim.
• Fixed Windows release bundle linking by using the static MSVC CRT expected by the bundled C++ translation runtime.
• This release candidate must pass Release Preflight on macOS, Windows, and Linux before a tag is created.

v0.3.11

• Fixed the Windows release workflow by reusing sidecars prepared during release checks instead of running the sidecar preparation step twice.
• Made sidecar preparation idempotent by skipping copies when the source and destination binaries are already identical.

v0.3.10

• Hardened the Windows Vite wrapper path normalization used by release builds.
• Split the GitHub Actions release bundle phase into explicit sidecar, frontend, and native bundle steps so Windows packaging failures are visible without raw log access.

v0.3.9

• Fixed Windows release builds by resolving the Vite wrapper root path with fileURLToPath, avoiding malformed /D:/... paths on GitHub Actions Windows runners.
• Re-publishing the v0.3.8 app changes with the Windows bundle fix so macOS, Windows, and Linux artifacts can be produced by the release workflow.

v0.3.8

• Added live local dictation for streaming STT models: the text overlay opens when recording starts, shows partial results while speaking, and still pastes only after stop.
• Improved the text overlay lifecycle so live dictation, translation, and paste errors do not overwrite each other; first-show startup races are handled through an explicit ready handshake.
• Added local selected-text translation with managed local translator options and selection hotkey settings.
• Improved local file transcription for WebM/video inputs and local streaming models by routing files through native preparation and streaming-compatible chunks.
• Reduced voice-history memory pressure by storing completed recording audio through the history audio store instead of keeping large base64 payloads in live history entries.
• Refreshed settings/model UI for local STT, local LLM, local translation, and development chat workflows.

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

Capability	Cloud	API	Local
Dictation, files, and local history	Yes	Yes	Yes
Streaming dictation	Yes	Verified models	Streaming-capable models
Selected-text translation	Yes	Yes	Yes
Speaker diarization	When the capability is available	Local diarization kit	Local diarization kit
Synchronous translation	Yes	Verified OpenAI/Gemini Realtime	No
Summaries and prompt processing	Yes	With a configured LLM	With a selected local LLM

The complete data routing, runtime processes, limitations, and failure boundaries are documented in the Russian-language Cloud/API/Local mode architecture. Verifiable user behavior is collected in the product business requirements.

Talkis Cloud

Sign in to Talkis Cloud and use transcription without managing API keys. Requests go through proxy.talkis.ru. Synchronous translation uses a short-lived Realtime credential issued by the authenticated proxy; the provider key is never stored in the desktop app.

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.

Realtime dictation and synchronous translation are enabled only after the exact provider, model, endpoint, and key configuration passes its connection check.

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 can keep both transcription and transcript summaries on your machine: STT models handle audio, and a separate local text LLM handles summary and prompt-based processing.

Managed local runtimes:

• Whisper, GigaAM GGUF, NVIDIA Parakeet GGUF, and Qwen ASR GGUF through the unified transcribe.cpp runtime, default endpoint http://127.0.0.1:8000
• Text LLM summaries through the bundled OpenAI-compatible talkis-llm runtime backed by GGUF models such as Qwen2.5 Instruct
• 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.

The call appears in history as soon as recording starts. Talkis checkpoints both audio tracks and the transcript draft while the call is active. Streaming STT models show live text in the Transcription tab, then the saved tracks refine the result after stop. After an unexpected shutdown, Talkis restores available audio and the latest durable draft on the next launch. GigaAM and other batch-only models transcribe the call after recording stops.

Synchronous Translation

Enable the translation button in Settings -> Translation, choose the target language, and start it from the floating widget. Cloud mode uses the Talkis proxy; API mode uses a verified OpenAI or Gemini Realtime adapter. Local mode does not provide synchronous translation, but local dictation, selected-text translation, file transcription, summaries, and other local features remain available.

The live text overlay keeps consecutive chunks from the same source together and stores the finished session in local history. On macOS, OpenAI-backed sessions can also play translated speech while reducing the original source volume.

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.

Product And Architecture Documentation

• Cloud/API/Local mode architecture — technical routing for dictation, files, calls, translation, LLM processing, and history.
• Talkis business requirements — user capabilities, expected behavior, limitations, and acceptance criteria.
• Audio pipeline principles — mandatory engineering rules for recording, STT, files, and call capture.
• Local STT runtime — managed local recognition architecture and contract.

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/                 Architecture, business requirements, 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.