What Programming Languages Are Used in Meetily? A Complete Stack Breakdown

Meetily is built with Rust for the native backend, TypeScript/React for the frontend UI, and Python plus shell scripts for development tooling and legacy utilities.

Meetily is a privacy-first AI meeting assistant developed by Zackriya-Solutions. As a modern Tauri desktop application, it combines multiple programming languages into a cohesive, high-performance stack. This article examines each language's role, how they interact, and where to find the relevant source code in the repository.

Rust: The Core Native Engine

Rust powers Meetily's performance-critical systems. It handles audio capture, real-time mixing, voice activity detection (VAD), Whisper speech-to-text integration, and local database operations.

The Rust codebase lives in frontend/src-tauri/src/ and is organized into focused modules:

Module	Key File	Responsibility
Entry point	lib.rs	Registers Tauri commands and initializes the runtime
Audio pipeline	audio/pipeline.rs	Professional audio mixing with RMS-based ducking
Recording commands	recording_commands.rs	Exposes start_recording and stop_recording to the UI
Whisper engine	whisper_engine/whisper_engine.rs	Model loading, GPU detection, and transcription orchestration

From frontend/src-tauri/src/lib.rs, the main command registration:

#[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> {
    audio::recording_commands::start(
        app,
        mic_device_name,
        system_device_name,
        meeting_name,
    )
    .await
}

The audio mixing implementation in pipeline.rs demonstrates Rust's suitability for low-latency signal processing:

pub fn mix_microphone_and_system(
    mic_buf: &[f32],
    sys_buf: &[f32],
) -> Vec<f32> {
    // RMS-based ducking to keep mic audible
    let rms = calculate_rms(sys_buf);
    let duck_factor = if rms > 0.1 { 0.5 } else { 1.0 };
    mic_buf.iter()
        .zip(sys_buf.iter())
        .map(|(m, s)| m + s * duck_factor)
        .collect()
}

Key dependencies in Cargo.toml include tauri, cpal for cross-platform audio, and whisper-rs for local speech recognition.

TypeScript and React: The Frontend UI

TypeScript with React 18 (via Next.js 14) builds Meetily's user interface. The frontend compiles into the Tauri shell, creating a single native binary with web-based developer ergonomics.

Critical frontend locations include:

• frontend/src/app/page.tsx — Main recording interface
• frontend/src/app/settings/page.tsx — Configuration UI
• frontend/src/lib/whisper.ts — Whisper service abstraction
• frontend/src/components/TranscriptView.tsx — Live transcript display

The frontend communicates with Rust through Tauri's invoke API. From frontend/src/lib/recordingNotification.tsx:

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

export async function startRecording(
  mic: string,
  system: string,
  meeting: string,
) {
  await invoke('start_recording', {
    mic_device_name: mic,
    system_device_name: system,
    meeting_name: meeting,
  });
}

React also listens for Rust-emitted events. The transcription worker in Rust sends updates via:

// From src-tauri/src/audio/transcription/worker.rs
app.emit("transcript-update", TranscriptUpdate { text, timestamp })?;

Which the TypeScript frontend receives and renders in real time.

Python: Legacy and Development Scripts

Python appears in Meetily's repository but does not run in production. These files serve archival, prototyping, and utility purposes:

Script	Location	Purpose
Transcript injector	scripts/inject_transcript.py	Bulk import transcript JSON for testing
Archived server	backend/app/main.py	Legacy FastAPI reference implementation

The Python scripts remain useful for developers exploring transcript data formats or migrating from earlier server-based architectures. For example, inject_transcript.py demonstrates JSON structure:

#!/usr/bin/env python3
import json, sys
from pathlib import Path

def inject(transcript_path, meeting_id):
    data = json.loads(Path(transcript_path).read_text())
    print(json.dumps({"meeting_id": meeting_id, "transcript": data}))

if __name__ == "__main__":
    inject(sys.argv[1], sys.argv[2])

Shell and Batch: Build Automation

Shell scripts streamline cross-platform development. Key automation includes:

• scripts/clean_run.sh — Cleans build artifacts, reinstalls dependencies, and launches the Tauri app
• backend/run-docker.sh — Docker container management for legacy backend services

These scripts ensure consistent developer experience across macOS, Windows, and Linux environments.

How the Languages Interact

Meetily's architecture follows a clear separation with defined communication patterns:

1. Frontend → Rust: TypeScript calls invoke Rust commands synchronously or asynchronously
2. Rust → Frontend: Rust emits events that React components subscribe to via listen
3. Rust internal: Audio pipeline and Whisper engine operate entirely in native code for performance
4. Auxiliary tooling: Python and shell scripts operate outside the runtime for development tasks

This polyglot approach leverages each language's strengths: Rust for systems programming, TypeScript/React for interface development, and Python for rapid scripting.

Summary

• Rust forms the production core: audio processing, transcription, and native system access in frontend/src-tauri/src/
• TypeScript/React delivers the UI through Next.js 14, communicating with Rust via Tauri's bridge
• Python exists only in scripts/ and backend/ as non-production tooling and legacy reference
• Shell scripts automate builds and development workflows across platforms

Frequently Asked Questions

Is Meetily built entirely in Rust?

No. While Rust powers the native backend and audio systems, the user interface is built with TypeScript and React. Meetily uses Tauri to combine these into a single desktop application.

Does Meetily use Python in production?

No. Python scripts in the repository are for development, testing, and archival purposes only. The production application runs Rust for all core functionality.

Why does Meetily use multiple programming languages?

Each language serves its optimal purpose: Rust provides memory-safe, low-latency audio processing; TypeScript/React enables rapid UI development with web technologies; and Python/shell scripts handle automation and legacy compatibility.

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