# How Meetily's Retranscription Feature Re-processes Recorded Meetings with Different Models or Languages

> Meetily's retranscription lets you re-process meetings with new models or languages. Discover how its Tauri Rust workflow dynamically loads models and tracks progress for enhanced meeting insights.

- Repository: [Zackriya Solutions/meetily](https://github.com/Zackriya-Solutions/meetily)
- Tags: how-to-guide
- Published: 2026-08-02

---

**Meetily's retranscription feature allows users to re-process stored audio files using different Whisper models and languages through an asynchronous Tauri Rust workflow that validates providers, loads models dynamically, and emits real-time progress events.**

The retranscription feature in Meetily (Zackriya-Solutions/meetily) provides a flexible mechanism for regenerating transcripts from existing recordings. Unlike live transcription, this capability allows users to experiment with different model sizes, switch languages, or migrate to improved AI providers without re-recording meetings. The implementation resides entirely in the Tauri Rust core and exposes a command-based API that the frontend consumes for seamless UI integration.

## Core Retranscription Workflow

The retranscription engine operates inside [`frontend/src-tauri/src/audio/retranscription.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/src/audio/retranscription.rs). When triggered, the `start_retranscription` command accepts five critical parameters: the meeting identifier, the folder containing the original audio file, the target language, the Whisper model name (e.g., `"base"`, `"small"`, `"medium"`), and the AI provider (Ollama, OpenAI, Groq) at line 89.

The workflow executes through the `run_retranscription` function, which orchestrates model loading, audio processing, and result storage.

## Concurrency Control and Safety

To prevent resource conflicts, Meetily implements a global atomic flag named `RETRANSCRIPTION_IN_PROGRESS`. This flag ensures only one retranscription job executes simultaneously across the entire application. A dedicated guard automatically releases this flag if the task panics, preventing deadlocks (lines 19-27 of [`frontend/src-tauri/src/audio/retranscription.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/src/audio/retranscription.rs)).

## Provider Validation and Model Loading

Before processing begins, the engine validates that the selected provider supports Whisper transcription. If an unsupported provider is chosen, the system emits a clear error event at line 612 of the retranscription module.

For valid providers, `run_retranscription` invokes `whisper_engine::WhisperEngine::load_model` at line 187, passing the user-specified model string. The engine automatically selects the appropriate GPU acceleration—Metal for macOS, CUDA for NVIDIA GPUs, or Vulkan as a fallback—or degrades gracefully to CPU execution ([`frontend/src-tauri/src/whisper_engine/whisper_engine.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/src/whisper_engine/whisper_engine.rs)).

## Language Selection and Processing

The language argument provided to `start_retranscription` is forwarded directly to Whisper's transcription call at line 187. This architecture allows the same audio file to be re-processed in different languages or locales without altering the source recording, enabling multilingual transcript generation from a single meeting.

## Data Persistence and Metadata Updates

Upon completion, Whisper returns the new transcript to the database layer (`database::repositories::transcript`). The system updates the original meeting metadata with a `retranscribed_at` timestamp and adds a `"source": "retranscription"` marker to distinguish regenerated transcripts from originals (lines 723-756 of [`frontend/src-tauri/src/audio/retranscription.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/src/audio/retranscription.rs)).

## Progress Reporting and Cancellation

Throughout the job lifecycle, the backend emits `"retranscription-progress"` events containing percentage completion data to keep the frontend responsive. Upon successful completion, a `"retranscription-complete"` event fires; errors trigger `"retranscription-error"` (lines 116-127).

Users can abort processing via the `cancel_retranscription` command, which clears the atomic flag and stops the workflow gracefully (lines 84-85).

## Frontend Integration

The three Tauri commands—`start_retranscription_command`, `cancel_retranscription_command`, and `is_retranscription_in_progress_command`—are registered in [`frontend/src-tauri/src/lib.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/src/lib.rs) at lines 742-744, making them available to the TypeScript frontend.

### Triggering Retranscription

To initiate retranscription from the frontend:

```typescript
import { invoke } from '@tauri-apps/api/tauri';

await invoke('start_retranscription_command', {
  meetingId: '12345',
  language: 'es',               // Spanish transcription
  model: 'small',               // Whisper "small" model
  provider: 'ollama'            // Provider supporting Whisper
});

```

### Checking Status and Cancelling

Check if a job is running:

```typescript
const inProgress = await invoke<boolean>('is_retranscription_in_progress_command');

```

Cancel an ongoing job:

```typescript
await invoke('cancel_retranscription_command');

```

### Listening for Progress

Implement real-time progress updates in React:

```tsx
import { listen } from '@tauri-apps/api/event';
import { useEffect, useState } from 'react';

function useRetranscriptionProgress() {
  const [progress, setProgress] = useState(0);
  useEffect(() => {
    const unlisten = listen<{ percent: number }>('retranscription-progress', e => {
      setProgress(e.payload.percent);
    });
    return () => { unlisten.then(f => f()); };
  }, []);
  return progress;
}

```

## Summary

- **Single Concurrency**: The `RETRANSCRIPTION_IN_PROGRESS` atomic flag prevents simultaneous retranscription jobs and automatically releases on panic.
- **Provider Flexibility**: Only Whisper-supporting providers (Ollama, OpenAI, Groq) are accepted, validated before model loading.
- **Dynamic Configuration**: Users specify model size (`base`, `small`, `medium`) and language independently for each retranscription job.
- **GPU Acceleration**: The Whisper engine automatically utilizes Metal, CUDA, or Vulkan, falling back to CPU when necessary.
- **Event-Driven UI**: Progress events (`retranscription-progress`, `retranscription-complete`, `retranscription-error`) enable responsive frontend implementations.
- **Safe Cancellation**: The `cancel_retranscription` command allows users to abort long-running jobs without restarting the application.

## Frequently Asked Questions

### What is Meetily's retranscription feature?

Meetily's retranscription feature is an asynchronous workflow that allows users to regenerate transcripts from previously recorded meeting audio using different Whisper AI models or languages. Unlike initial recording transcription, it operates on stored audio files in [`frontend/src-tauri/src/audio/retranscription.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/src/audio/retranscription.rs), enabling experimentation with model accuracy or multilingual output without re-recording.

### Which AI providers support retranscription in Meetily?

The retranscription feature supports providers capable of running Whisper models, specifically Ollama, OpenAI, and Groq. The system validates provider compatibility at line 612 of [`frontend/src-tauri/src/audio/retranscription.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/src/audio/retranscription.rs) and rejects unsupported providers before model loading begins.

### How does Meetily handle GPU acceleration during retranscription?

The `whisper_engine::WhisperEngine::load_model` function automatically detects and utilizes available hardware acceleration. It prioritizes Metal on macOS, CUDA on NVIDIA GPUs, and Vulkan as a cross-platform alternative, falling back to CPU execution if no GPU is available ([`frontend/src-tauri/src/whisper_engine/whisper_engine.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/src/whisper_engine/whisper_engine.rs)).

### Can users cancel an ongoing retranscription job?

Yes. Users can invoke the `cancel_retranscription_command`, which clears the `RETRANSCRIPTION_IN_PROGRESS` atomic flag and halts processing immediately (lines 84-85 of [`frontend/src-tauri/src/audio/retranscription.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/src/audio/retranscription.rs)). The frontend can check active status anytime using `is_retranscription_in_progress_command`.