# Meetily Whisper Model Storage Locations on macOS, Windows, and Linux

> Find Meetily Whisper model storage locations on macOS, Windows, and Linux. Learn where Meetily saves model files in its application data directories.

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

---

**Meetily stores Whisper model files in platform-specific application data directories under a `models` subdirectory, using Tauri's `app_data_dir` API to resolve paths on macOS (`~/Library/Application Support/Meetily/models/`), Windows (`%APPDATA%\Meetily\models\`), and Linux (`$XDG_DATA_HOME/Meetily/models/`).**

Meetily is an open-source meeting transcription application built with the Tauri framework. Knowing the exact **Whisper model storage locations** helps you manage disk space, backup custom models, or troubleshoot download failures.

## Default Whisper Model Storage Locations by Platform

Meetily delegates path resolution to Tauri's `app_data_dir` function, then appends `"models"` to construct the final directory. The implementation 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) (lines 93-100) handles this logic for production builds.

### macOS

On macOS, Meetily stores models at:

```text
~/Library/Application Support/Meetily/models/

```

The path is constructed by resolving `app_data_dir` to `~/Library/Application Support/Meetily` and appending the `"models"` subdirectory. This follows Apple's standard for application support files.

### Windows

On Windows systems, the storage location is:

```text
%APPDATA%\Meetily\models\

```

Tauri resolves `app_data_dir` to `%APPDATA%\Meetily`, and the code appends `"models"` to create the final path. This ensures models persist across user sessions in the standard roaming application data folder.

### Linux

On Linux distributions, Meetily adheres to the XDG Base Directory Specification:

```text
$XDG_DATA_HOME/Meetily/models/

```

If `$XDG_DATA_HOME` is unset, the fallback location is:

```text
$HOME/.local/share/Meetily/models/

```

Tauri's `app_data_dir` automatically handles the XDG compliance, after which Meetily appends the `"models"` folder.

### Development Mode

When running from the source repository during development, Meetily checks for a local models folder first:

```text
<repo-root>/frontend/models/

```

This fallback logic exists in [`whisper_engine.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/whisper_engine.rs) (lines 100-108), allowing developers to test without writing to system directories.

## How the Models Directory Is Initialized

The initialization sequence begins in [`frontend/src-tauri/src/whisper_engine/commands.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/src/whisper_engine/commands.rs), which retrieves the `app_data_dir` using Tauri's path API. The core `WhisperEngine` struct in [`whisper_engine.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/whisper_engine.rs) accepts this path during construction, creating the `models` subdirectory if it does not exist.

The directory determination follows this priority:

1. Development check: If `<repo-root>/frontend/models/` exists, use it
2. Production fallback: Use `app_data_dir()/models` based on the operating system

## Accessing Model Paths Programmatically

You can retrieve the models directory path from both the Rust backend and TypeScript frontend.

### From Rust (Backend)

```rust
use frontend::src_tauri::whisper_engine::WhisperEngine;

// Initialize with default models directory
let engine = WhisperEngine::new()?;
let model = engine.load_model("base").await?;

```

### From TypeScript (Frontend)

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

async function getModelsDir(): Promise<string> {
  const dataDir = await app.path.appDataDir();  // e.g., ~/Library/Application Support/Meetily
  return `${dataDir}/models`;
}

```

### Custom Models Directory

For testing or specific deployment scenarios, instantiate the engine with a custom path:

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

let custom_dir = PathBuf::from("/mnt/external/meetily_models");
let engine = WhisperEngine::new_with_models_dir(Some(custom_dir))?;

```

## Summary

- **macOS**: `~/Library/Application Support/Meetily/models/`
- **Windows**: `%APPDATA%\Meetily\models\`
- **Linux**: `$XDG_DATA_HOME/Meetily/models/` (or `~/.local/share/Meetily/models/`)
- **Development**: `<repo-root>/frontend/models/`
- **Implementation**: 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) (lines 93-108) and documented in [`CLAUDE.md`](https://github.com/Zackriya-Solutions/meetily/blob/main/CLAUDE.md)

## Frequently Asked Questions

### Can I change the default Whisper model storage location?

Yes. While Meetily defaults to the platform-specific `app_data_dir`, you can instantiate the `WhisperEngine` with a custom path using `WhisperEngine::new_with_models_dir()` in Rust, or set environment variables before launch to override the base directory.

### What happens if I delete the models folder?

Meetily will recreate the `models` directory automatically on the next launch if it attempts to download or access a model. However, downloaded model files (such as GGML binaries) will need to be re-downloaded, which occurs on demand when transcription is requested.

### Are models shared between different Meetily installations?

Only if the installations run under the same user profile on the same machine. Since paths are user-specific (resolving to home directories or `%APPDATA%`), system-wide or multi-user sharing requires manually configuring a custom models directory accessible to all users.

### How do I manually add a Whisper model file?

Place the downloaded model file (e.g., `ggml-base.bin`) directly into the platform-specific `models` folder listed above. Meetily scans this directory on startup, so the model should appear in the available models list without requiring a restart.