Tauri Plugin STT (Speech-to-Text)

Cross-platform speech recognition plugin for Tauri 2.x applications. Provides real-time speech-to-text functionality for desktop (Windows, macOS, Linux) and mobile (iOS, Android).

Features

• 🎤 Real-time Speech Recognition - Convert speech to text with low latency
• 📱 Cross-platform Support - iOS, Android, macOS, Windows, Linux
• 🌐 Multi-language Support - 9 languages with automatic model download
• 📝 Interim Results - Get partial transcriptions while speaking
• 🔄 Continuous Mode - Auto-restart recognition after each utterance
• 🔐 Permission Handling - Request and check microphone/speech permissions
• 📥 Auto Model Download - Vosk models are downloaded automatically on first use

Platform Support

| Platform | Status | API Used | Model Download | | -------- | ------- | ------------------------------------- | -------------- | | iOS | ✅ Full | SFSpeechRecognizer (Speech framework) | Not required | | Android | ✅ Full | SpeechRecognizer API | Not required | | macOS | ✅ Full | Vosk (offline speech recognition) | Automatic | | Windows | ✅ Full | Vosk (offline speech recognition) | Automatic | | Linux | ✅ Full | Vosk (offline speech recognition) | Automatic |

Supported Languages (Desktop)

| Language | Code | Model Size | | ---------- | ----- | ---------- | | English | en-US | 40 MB | | Portuguese | pt-BR | 31 MB | | Spanish | es-ES | 39 MB | | French | fr-FR | 41 MB | | German | de-DE | 45 MB | | Russian | ru-RU | 45 MB | | Chinese | zh-CN | 43 MB | | Japanese | ja-JP | 48 MB | | Italian | it-IT | 39 MB |

Models are downloaded automatically from alphacephei.com/vosk/models when you first use a language.

Installation

Rust

Add the plugin to your Cargo.toml:

[dependencies]
tauri-plugin-stt = "0.1"

TypeScript

Install the JavaScript guest bindings:

npm install tauri-plugin-stt-api
# or
yarn add tauri-plugin-stt-api
# or
pnpm add tauri-plugin-stt-api

Setup

Register Plugin

In your Tauri app setup:

fn main() {
    tauri::Builder::default()
        .plugin(tauri_plugin_stt::init())
        .run(tauri::generate_context!())
        .expect("error while running application");
}

Permissions

Add permissions to your capabilities/default.json:

{
  "permissions": ["stt:default"]
}

For granular permissions, you can specify individual commands:

{
  "permissions": [
    "stt:allow-is-available",
    "stt:allow-get-supported-languages",
    "stt:allow-check-permission",
    "stt:allow-request-permission",
    "stt:allow-start-listening",
    "stt:allow-stop-listening",
    "stt:allow-register-listener",
    "stt:allow-remove-listener"
  ]
}

For granular permissions, you can specify individual commands:

{
  "permissions": [
    "stt:allow-is-available",
    "stt:allow-get-supported-languages",
    "stt:allow-check-permission",
    "stt:allow-request-permission",
    "stt:allow-start-listening",
    "stt:allow-stop-listening",
    "stt:allow-register-listener",
    "stt:allow-remove-listener"
  ]
}

Vosk Library (Desktop Only)

The Vosk runtime library must be installed on your system:

macOS

# Download and install libvosk
curl -LO https://github.com/alphacep/vosk-api/releases/download/v0.3.42/vosk-osx-0.3.42.zip
unzip vosk-osx-0.3.42.zip
sudo cp vosk-osx-0.3.42/libvosk.dylib /usr/local/lib/

Linux

wget https://github.com/alphacep/vosk-api/releases/download/v0.3.42/vosk-linux-x86_64-0.3.42.zip
unzip vosk-linux-x86_64-0.3.42.zip
sudo cp vosk-linux-x86_64-0.3.42/libvosk.so /usr/local/lib/
sudo ldconfig

Windows

Download from GitHub Releases and add to PATH.

Usage

TypeScript API

import {
  isAvailable,
  getSupportedLanguages,
  startListening,
  stopListening,
  onResult,
  onStateChange,
  onError,
} from "tauri-plugin-stt-api";

// Check if STT is available
const result = await isAvailable();

// Get supported languages (with installed status)
const languages = await getSupportedLanguages();

// Listen for results
const resultListener = await onResult(result => {
  console.log("Recognized:", result.transcript, result.isFinal);
});

// Listen for download progress (when model is being downloaded)
import { listen } from "@tauri-apps/api/event";
const downloadListener = await listen<{
  status: string;
  model: string;
  progress: number;
}>("stt://download-progress", event => {
  console.log(`${event.payload.status}: ${event.payload.progress}%`);
});

// Start listening
await startListening({
  language: "en-US",
  interimResults: true,
  continuous: true,
  // maxDuration and onDevice are supported by the guest SDK
});

// Stop listening
await stopListening();

Configuration Options

interface ListenConfig {
  language?: string; // Language code (e.g., "en-US", "pt-BR")
  interimResults?: boolean; // Return partial results while speaking
  continuous?: boolean; // Continue listening after utterance ends
  maxDuration?: number; // Max listening duration in milliseconds (0 = unlimited)
  onDevice?: boolean; // Prefer on-device recognition (iOS)
}

Event Listeners

// Listen for results
const unlistenResult = await onResult(result => {
  console.log(result.transcript, result.isFinal);
});

// Listen for state changes
const unlistenState = await onStateChange(event => {
  console.log("State:", event.state); // "idle" | "listening" | "processing"
});

// Listen for errors
const unlistenError = await onError(error => {
  console.error(`[${error.code}] ${error.message}`);
});

// Clean up listeners
unlistenResult();
unlistenState();
unlistenError();

Events

| Event | Payload | Description | | ------------------------- | -------------------------------------- | ---------------------------------------- | | stt://result | { transcript, isFinal, confidence? } | Recognition result | | stt://state-change | { state } | State change (idle/listening/processing) | | stt://error | { code, message, details? } | Error event | | stt://download-progress | { status, model, progress } | Model download progress |

API Reference

startListening(config?: ListenConfig): Promise<void>

Start speech recognition.

Config Options:

• language: Language code (e.g., "en-US", "pt-BR")
• interimResults: Return partial results (default: false)
• continuous: Continue listening after utterance ends (default: false)
• maxDuration: Max listening duration in ms (0 = unlimited)
• onDevice: Use on-device recognition (iOS only, default: false)

stopListening(): Promise<void>

Stop current speech recognition session.

isAvailable(): Promise<AvailabilityResponse>

Check if STT is available on the device.

Returns:

• available: Whether STT is available
• reason: Optional reason if unavailable

getSupportedLanguages(): Promise<SupportedLanguagesResponse>

Get list of supported languages.

Returns: Array of languages with:

• code: Language code (e.g., "en-US")
• name: Display name
• installed: Whether model is installed (desktop only)

checkPermission(): Promise<PermissionResponse>

Check current permission status.

Returns:

• microphone: "granted" | "denied" | "unknown"
• speechRecognition: "granted" | "denied" | "unknown"

requestPermission(): Promise<PermissionResponse>

Request microphone and speech recognition permissions.

Returns: Same as checkPermission()

onResult(handler: (result: RecognitionResult) => void): Promise<UnlistenFn>

Listen for recognition results.

Result:

• transcript: Recognized text
• isFinal: Whether this is a final result
• confidence: Confidence score (0.0-1.0, if available)

onStateChange(handler: (event: StateChangeEvent) => void): Promise<UnlistenFn>

Listen for state changes.

States: "idle", "listening", "processing"

onError(handler: (error: SttError) => void): Promise<UnlistenFn>

Listen for errors.

Error Codes:

• NOT_AVAILABLE: STT not available on device
• PERMISSION_DENIED: Microphone permission denied
• SPEECH_PERMISSION_DENIED: Speech recognition permission denied
• NETWORK_ERROR: Network error (server-based recognition)
• AUDIO_ERROR: Audio capture error
• TIMEOUT: Recognition timeout
• NO_SPEECH: No speech detected
• LANGUAGE_NOT_SUPPORTED: Requested language not supported
• CANCELLED: Recognition cancelled by user
• ALREADY_LISTENING: Already in listening state
• NOT_LISTENING: Not currently listening
• BUSY: Recognizer busy
• UNKNOWN: Unknown error

Building

Without STT (Default)

npm run dev

With STT

npm run dev -- --features stt
# or
npm run dev:stt

Troubleshooting

Desktop: "library 'vosk' not found"

Solution: Install the Vosk library as described in the Vosk Library section.

# macOS
ls /usr/local/lib/libvosk.dylib  # Should exist

# Linux
ldconfig -p | grep vosk  # Should show libvosk.so

# Windows
where vosk.dll  # Should be in PATH

Desktop: "Model not found" or automatic download fails

Problem: Vosk models are downloaded automatically on first use for each language.

Solution:

1. Ensure internet connectivity
2. Check app data directory: ~/.local/share/tauri-plugin-stt/models/ (Linux/macOS) or %APPDATA%/tauri-plugin-stt/models/ (Windows)
3. Manual download: Download from alphacephei.com/vosk/models and extract to models directory
4. Model naming: Ensure folder name matches expected pattern (e.g., vosk-model-small-en-us-0.15)

Mobile: "Speech recognition not available"

iOS Solution:

1. Ensure iOS 10+ (speech recognition requires iOS 10+)
2. Check Settings → Privacy → Speech Recognition → Enable for your app
3. For on-device recognition, iOS 13+ is required

Android Solution:

1. Install Google app (provides speech recognition service)
2. Check Settings → Apps → Default apps → Digital assistant app
3. Ensure internet connectivity for server-based recognition

Permission denied errors

Solution: Call requestPermission() before startListening()

const perm = await requestPermission();
if (perm.microphone !== "granted") {
  console.error("Microphone permission required");
  return;
}
await startListening();

No audio input detected

Checklist:

• ✅ Microphone is working in other apps
• ✅ Correct microphone selected in system settings
• ✅ Microphone not muted (hardware or software)
• ✅ App has microphone permission
• ✅ No other app is using the microphone exclusively

Interim results not showing

Note: Interim results availability varies by platform:

• iOS/Android: Full support
• Desktop (Vosk): Partial support (depends on model)

await startListening({
  interimResults: true, // Enable interim results
  continuous: true, // Keep listening
});

Recognition accuracy is low

Tips:

• Use correct language code for your accent (e.g., "en-GB" vs "en-US")
• Speak clearly and avoid background noise
• On iOS, download enhanced voices in Settings → Accessibility → Spoken Content
• Desktop: Use larger Vosk models for better accuracy (at cost of size)

"ALREADY_LISTENING" error

Solution: Stop current session before starting a new one:

try {
  await stopListening();
} catch (e) {
  // Ignore if not listening
}
await startListening();

Download progress events not firing

Note: Download progress events are only for desktop (Vosk models). Mobile uses native speech recognition without downloads.

import { listen } from "@tauri-apps/api/event";

const unlisten = await listen("stt://download-progress", event => {
  console.log(`${event.payload.status}: ${event.payload.progress}%`);
});

Examples

See the examples/stt-example directory for a complete working demo with React + Material UI, featuring:

• Real-time transcription with interim results
• Language selection
• Permission handling
• Error handling with visual feedback
• Download progress monitoring
• Results history

Platform-Specific Notes

iOS

• Requires iOS 10+ for basic speech recognition
• iOS 13+ required for on-device recognition (onDevice: true)
• Must add NSSpeechRecognitionUsageDescription to Info.plist
• Must add NSMicrophoneUsageDescription to Info.plist

Android

• Requires Android API 23+ (Android 6.0+)
• Google app must be installed for speech recognition
• Internet required for server-based recognition
• Must request RECORD_AUDIO permission in AndroidManifest.xml

Desktop (Windows, macOS, Linux)

• Requires Vosk library installation (see Vosk Library section)
• Models downloaded automatically (40-50 MB per language)
• Fully offline after model download
• Models stored in app data directory

License

MIT