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

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 (lines 93-100) handles this logic for production builds.

macOS

On macOS, Meetily stores models at:

~/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:

%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:

$XDG_DATA_HOME/Meetily/models/

If $XDG_DATA_HOME is unset, the fallback location is:

$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:

<repo-root>/frontend/models/

This fallback logic exists in 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, which retrieves the app_data_dir using Tauri's path API. The core WhisperEngine struct in 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)

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)

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:

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 (lines 93-108) and documented in 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.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}