What Programming Languages and Frameworks Does Meetily Use? Complete Stack Breakdown

Meetily combines a TypeScript and Next.js 14 frontend with a Rust and Tauri 2 native desktop shell, using specialized Rust crates for audio capture, GPU‑accelerated transcription, local LLM summarization, and SQLite persistence.

Meetily is a privacy‑first AI meeting assistant developed by Zackriya‑Solutions. Understanding the programming languages and frameworks behind Meetily is key to seeing how it delivers fast, offline‑capable transcription and LLM summarization inside a lightweight desktop application. The repository pairs a modern web‑based UI with a high‑performance Rust core to keep all meeting data on the local machine.

Frontend: TypeScript and Next.js 14

The user interface is a web layer that runs inside a Tauri native window. According to frontend/package.json, the UI is authored in TypeScript and JavaScript and orchestrated by Next.js 14 with React 18 as the underlying view library.

Key supporting libraries include:

• Radix UI, shadcn/ui, and Blocknote for component architecture
• Tailwind CSS for utility‑first styling
• Zod and React Hook Form for schema validation and form state

Because the frontend is bundled as a local web app rather than served remotely, it retains full access to the desktop APIs that Tauri exposes.

Desktop Shell: Rust and Tauri 2

Meetily’s native wrapper is written in Rust and built on Tauri 2. The shell bundles the Next.js frontend and securely exposes native capabilities through Tauri commands registered in frontend/src-tauri/src/lib.rs.

The Rust side uses:

• tokio and async‑trait for asynchronous runtime behavior
• @tauri-apps/plugin-fs for filesystem access
• plugin-notification, plugin-store, and plugin-updater for native desktop integrations

Dependency declarations and platform features are centralized in frontend/src-tauri/Cargo.toml.

Audio Capture and Processing

Audio handling is implemented entirely in Rust as a custom pipeline. The core stack relies on cpal for cross‑platform audio I/O and ffmpeg‑sidecar for system‑audio capture.

Additional crates found in the Rust audio modules include:

• ebur128 for loudness normalization
• nnnoiseless for noise suppression
• silero_rs for voice activity detection (VAD)
• ringbuf for lock‑free buffering
• rubato for audio resampling
• rayon for parallel processing

The implementation lives under frontend/src-tauri/src/audio/, with core mixing and VAD logic in frontend/src-tauri/src/audio/pipeline.rs.

Speech‑to‑Text Engine

Transcription is handled by two Rust engines. The primary engine uses whisper‑rs, a Rust binding to Whisper.cpp that supports optional GPU acceleration. A secondary fast‑transcription path uses Parakeet, which runs on ONNX Runtime via the ort crate.

GPU acceleration is controlled by Cargo feature flags in frontend/src-tauri/Cargo.toml (lines 38–53). Available backends include:

• Metal for Apple Silicon
• CUDA for NVIDIA GPUs
• Vulkan, HIPBLAS, and OpenBLAS for additional hardware targets

The transcription interface is implemented in frontend/src-tauri/src/whisper_engine/whisper_engine.rs.

LLM Summarization Layer

The summarization engine is also written in Rust. It includes built‑in support for routing requests to local or hosted models through Ollama, OpenAI, Anthropic, Groq, and OpenRouter.

Client crates—ollama, openai, anthropic, groq, and openrouter—work alongside serde and reqwest to serialize requests and manage HTTP traffic without leaving the local application context.

Local Persistence with SQLite

Meetily stores meetings, transcripts, settings, and analytics locally using SQLx with SQLite. This removes cloud dependency and preserves privacy.

Supporting persistence crates include:

• sqlx for async database access
• chrono for date and time handling
• serde_json for serialization
• once_cell for global lazy initialization

How the Frontend and Rust Core Communicate

The TypeScript frontend and Rust backend communicate through Tauri commands. The Next.js UI calls invoke() from @tauri-apps/api/core, while the Rust side exposes typed async commands in frontend/src-tauri/src/lib.rs.

For example, the frontend starts a recording by invoking a Rust command:

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

// Start a meeting recording and listen for status updates
async function startMeeting() {
  await invoke('start_recording_with_devices_and_meeting', {
    mic_device_name: 'Built‑in Microphone',
    system_device_name: 'BlackHole 2ch',
    meeting_name: 'Weekly Sync',
  });
}

(source: frontend/src/app/page.tsx)

On the Rust side, the matching command signature is:

#[tauri::command]
async fn start_recording<R: Runtime>(
    app: AppHandle<R>,
    mic_device_name: Option<String>,
    system_device_name: Option<String>,
    meeting_name: Option<String>,
) -> Result<(), String> {
    // ... implementation ...
}

(source: frontend/src-tauri/src/lib.rs)

Similarly, listing available devices is exposed as:

#[tauri::command]
async fn get_audio_devices() -> Result<Vec<AudioDevice>, String> {
    list_audio_devices()
        .await
        .map_err(|e| format!("Failed to list audio devices: {}", e))
}

(source: frontend/src-tauri/src/lib.rs, lines 85–90)

GPU Acceleration and Build Configuration

Cross‑platform GPU support is configured in frontend/src-tauri/Cargo.toml. Feature flags automatically enable the best available backend at compile time:

# Cargo.toml – feature list

[features]
default = ["platform-default"]
metal = ["whisper-rs/metal"]
cuda  = ["whisper-rs/cuda"]
vulkan = ["whisper-rs/vulkan"]

(source: frontend/src-tauri/Cargo.toml, lines 38–53)

When a compatible GPU is present, these features route Whisper inference through Metal, CUDA, or Vulkan rather than the CPU, delivering up to 10× faster transcription.

Summary

• Meetily’s frontend is built with TypeScript, Next.js 14, and React 18, styled with Tailwind CSS and component libraries declared in frontend/package.json.
• The native desktop shell uses Rust and Tauri 2, with command registration centralized in frontend/src-tauri/src/lib.rs.
• Audio capture and processing rely on a Rust pipeline using cpal, ffmpeg‑sidecar, and specialized crates for VAD, noise suppression, and resampling housed in frontend/src-tauri/src/audio/pipeline.rs.
• Transcription is powered by whisper‑rs and Parakeet, with GPU acceleration toggled through Cargo features in frontend/src-tauri/Cargo.toml.
• LLM summaries are generated via a Rust engine supporting Ollama, OpenAI, Anthropic, Groq, and OpenRouter.
• All data is persisted locally through SQLx and SQLite, ensuring a privacy‑first architecture.
• The UI and core communicate through Tauri commands, with the frontend using invoke() and the backend exposing typed Rust functions.

Frequently Asked Questions

Does Meetily use Electron for its desktop shell?

No. According to the Zackriya‑Solutions/meetily source code, the application uses Tauri 2 instead of Electron. Tauri provides a lightweight Rust‑based wrapper that bundles the Next.js frontend and exposes native APIs with a smaller memory footprint than traditional Electron apps.

Can Meetily run transcription entirely offline?

Yes. The Rust backend loads local Whisper models through whisper‑rs and runs inference on the CPU or a local GPU via backends such as Metal, CUDA, and Vulkan. The optional Ollama client integration also enables fully local LLM summarization without sending data to external servers.

What database does Meetily use to store meeting data?

Meetily uses SQLite accessed through the SQLx async Rust crate. All meetings, transcripts, settings, and analytics are stored locally, aligning with the project’s privacy‑first design.

How does the frontend communicate with the Rust audio engine?

The Next.js frontend calls Rust functions through Tauri commands using invoke() from @tauri-apps/api/core. For example, start_recording_with_devices_and_meeting is invoked from frontend/src/app/page.tsx and handled by an async Rust command defined in frontend/src-tauri/src/lib.rs.

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