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

> Discover Meetily's tech stack: TypeScript, Nextjs 14, Rust, and Tauri 2. Learn about its audio capture, transcription, summarization, and persistence technologies.

- Repository: [Zackriya Solutions/meetily](https://github.com/Zackriya-Solutions/meetily)
- Tags: deep-dive
- Published: 2026-07-27

---

**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`](https://github.com/Zackriya-Solutions/meetily/blob/main/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`](https://github.com/Zackriya-Solutions/meetily/blob/main/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`](https://github.com/Zackriya-Solutions/meetily/blob/main/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`](https://github.com/Zackriya-Solutions/meetily/blob/main/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`](https://github.com/Zackriya-Solutions/meetily/blob/main/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`](https://github.com/Zackriya-Solutions/meetily/blob/main/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`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/src/lib.rs).

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

```typescript
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`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src/app/page.tsx))*

On the Rust side, the matching command signature is:

```rust
#[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`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/src/lib.rs))*

Similarly, listing available devices is exposed as:

```rust
#[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`](https://github.com/Zackriya-Solutions/meetily/blob/main/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`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/Cargo.toml). Feature flags automatically enable the best available backend at compile time:

```toml

# 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`](https://github.com/Zackriya-Solutions/meetily/blob/main/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`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/package.json).
- The native desktop shell uses **Rust** and **Tauri 2**, with command registration centralized in [`frontend/src-tauri/src/lib.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/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`](https://github.com/Zackriya-Solutions/meetily/blob/main/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`](https://github.com/Zackriya-Solutions/meetily/blob/main/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`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src/app/page.tsx) and handled by an async Rust command defined in [`frontend/src-tauri/src/lib.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/src/lib.rs).