# How to Configure Custom Whisper Models and Paths in Meetily

> Configure custom Whisper models and paths in Meetily easily. Learn how to instantiate WhisperEngine with a custom directory and register your model in config.rs for enhanced functionality.

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

---

**You can configure custom Whisper models and paths in Meetily by instantiating `WhisperEngine` with a custom directory via `new_with_models_dir()` and registering your model in the `WHISPER_MODEL_CATALOG` static array in [`config.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/config.rs).**

Meetily, an open-source meeting transcription tool from Zackriya-Solutions/meetily, uses a Rust-based `WhisperEngine` to handle speech-to-text processing. By default, the engine searches for models in development folders like `frontend/models` or the OS data directory in production, but you can override these locations and add bespoke model entries to fit your specific requirements.

## Understanding the WhisperEngine Configuration

The transcription engine initializes through `WhisperEngine::new_with_models_dir()` in [`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). This constructor accepts an optional `PathBuf` parameter that defines where the engine looks for Whisper model files (e.g., `ggml-tiny.bin`, `ggml-base-q5_1.bin`). When you provide a custom path, the engine bypasses default directories and uses your specified location for model discovery, validation, and loading.

## Setting a Custom Models Directory

### Runtime Configuration via new_with_models_dir

To point Meetily at a specific folder containing your Whisper models, instantiate the engine with your custom path:

```rust
use std::path::PathBuf;
use meetily::frontend::src_tauri::whisper_engine::WhisperEngine;

// Point to a user-specified models folder
let custom_dir = PathBuf::from("/home/alice/meetily_models");
let engine = WhisperEngine::new_with_models_dir(Some(custom_dir))
    .expect("Failed to initialise WhisperEngine");

```

This method, defined at lines 83-105 in [`whisper_engine.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/whisper_engine.rs), sets the internal `models_dir` field that subsequent operations reference.

### Dynamic Path Updates via Tauri Commands

For runtime updates from the UI, expose a Tauri command that reinitializes the engine with a new directory:

```rust
#[tauri::command]
async fn set_custom_models_path(app_handle: tauri::AppHandle, path: String) -> Result<(), String> {
    let engine = app_handle.state::<WhisperEngine>();
    let new_engine = WhisperEngine::new_with_models_dir(Some(PathBuf::from(path)))
        .map_err(|e| e.to_string())?;
    *engine = new_engine;
    Ok(())
}

```

Register this command in [`frontend/src-tauri/src/lib.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/src/lib.rs) to allow the frontend to invoke path changes dynamically.

## Adding Custom Models to the Catalog

Before the engine can recognize a custom model, you must register it in the `WHISPER_MODEL_CATALOG` static array located in [`frontend/src-tauri/src/config.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/src/config.rs). This catalog defines the model's display name, filename, size, and performance characteristics.

Add your custom entry following the tuple structure `(name, filename, size_mb, accuracy, speed, description)`:

```rust
// In config.rs
pub const WHISPER_MODEL_CATALOG: &[(&str, &str, u32, &str, &str, &str)] = &[
    ("tiny", "ggml-tiny.bin", 75, "low", "fast", "Original tiny model"),
    // Custom model entry
    ("my-custom-large", "ggml-my-custom-large.bin", 3900,
        "high", "medium", "Fine-tuned large model for specialized vocabulary"),
];

```

The engine uses this metadata during discovery and validation to confirm file integrity and present options to users.

## Model Discovery, Download, and Loading

### Discovering Available Models

After initialization, call `discover_models()` to scan the configured directory and verify which catalog entries exist, checking file sizes and corruption status:

```rust
let available = engine.discover_models().await?;
for model in available {
    println!("{} – status: {:?}", model.name, model.status);
}

```

This implementation in [`whisper_engine.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/whisper_engine.rs) (lines 71-78) returns the current state of each model without loading them into memory.

### Downloading Models

If your custom model is hosted at a URL supported by Meetily's download logic, use the built-in downloader:

```rust
engine.download_model("my-custom-large", None).await?;

```

For models hosted elsewhere or manually transferred, skip this step and place the file directly in your custom models directory with the exact filename specified in the catalog.

### Loading Models for Transcription

Activate a specific model for inference using `load_model()`:

```rust
engine.load_model("my-custom-large").await?;

```

Once loaded, the model remains active for subsequent transcription calls like `transcribe_audio()` or `transcribe_audio_with_confidence()`. The loading logic (lines 61-70 in [`whisper_engine.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/whisper_engine.rs)) handles GPU-aware context initialization automatically.

## Summary

- **Override default paths** by instantiating `WhisperEngine` with `new_with_models_dir(Some(PathBuf::from("...")))` to point to any readable directory.
- **Register custom models** in the `WHISPER_MODEL_CATALOG` static array in [`frontend/src-tauri/src/config.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/src/config.rs) with metadata including filename, size, and performance labels.
- **Manage model lifecycle** through `discover_models()` for validation, `download_model()` for retrieval, and `load_model()` for activation.
- **Expose runtime configuration** via Tauri commands to allow UI-driven path changes without restarting the application.

## Frequently Asked Questions

### What file formats does Meetily support for Whisper models?

Meetily expects Whisper models in the GGML format, specifically files with extensions like `.bin` (e.g., `ggml-tiny.bin`, `ggml-base-q5_1.bin`). The engine validates these files during the discovery phase by checking their presence in the configured directory and verifying expected file sizes against the `WHISPER_MODEL_CATALOG` entries.

### How do I point Meetily to an existing Whisper model directory?

Pass the directory path to `WhisperEngine::new_with_models_dir()` when creating the engine instance. This method, located in [`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), accepts an optional `PathBuf` and directs all model operations to your specified location instead of the default development or OS data directories.

### Can I use fine-tuned or specialized Whisper models with Meetily?

Yes. Add your fine-tuned model to the `WHISPER_MODEL_CATALOG` in [`frontend/src-tauri/src/config.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/src/config.rs) with the appropriate filename, size in megabytes, and descriptive metadata. Place the actual `.bin` file in your configured models directory, and the engine will treat it as a selectable option alongside standard Whisper variants.

### Where does Meetily store models by default?

In development environments, Meetily searches for models in `frontend/models` and other legacy locations. In production builds, it uses the OS-specific data directory. You can override either location by providing a custom path to `WhisperEngine::new_with_models_dir()` at initialization.