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

> Discover the programming languages powering Meetily. Explore Rust backend, TypeScript/React frontend, and Python tooling in this complete stack breakdown.

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

---

**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`](https://github.com/Zackriya-Solutions/meetily/blob/main/lib.rs) | Registers Tauri commands and initializes the runtime |
| Audio pipeline | [`audio/pipeline.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/audio/pipeline.rs) | Professional audio mixing with RMS-based ducking |
| Recording commands | [`recording_commands.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/recording_commands.rs) | Exposes `start_recording` and `stop_recording` to the UI |
| Whisper engine | [`whisper_engine/whisper_engine.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/whisper_engine/whisper_engine.rs) | Model loading, GPU detection, and transcription orchestration |

From [`frontend/src-tauri/src/lib.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/src/lib.rs), the main command registration:

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

```

The audio mixing implementation in [`pipeline.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/pipeline.rs) demonstrates Rust's suitability for low-latency signal processing:

```rust
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`](https://github.com/Zackriya-Solutions/meetily/blob/main/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`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src/app/page.tsx) — Main recording interface
- [`frontend/src/app/settings/page.tsx`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src/app/settings/page.tsx) — Configuration UI
- [`frontend/src/lib/whisper.ts`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src/lib/whisper.ts) — Whisper service abstraction
- [`frontend/src/components/TranscriptView.tsx`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src/components/TranscriptView.tsx) — Live transcript display

The frontend communicates with Rust through Tauri's `invoke` API. From [`frontend/src/lib/recordingNotification.tsx`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src/lib/recordingNotification.tsx):

```typescript
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:

```rust
// 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`](https://github.com/Zackriya-Solutions/meetily/blob/main/scripts/inject_transcript.py) | Bulk import transcript JSON for testing |
| Archived server | [`backend/app/main.py`](https://github.com/Zackriya-Solutions/meetily/blob/main/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`](https://github.com/Zackriya-Solutions/meetily/blob/main/inject_transcript.py) demonstrates JSON structure:

```python
#!/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`](https://github.com/Zackriya-Solutions/meetily/blob/main/scripts/clean_run.sh) — Cleans build artifacts, reinstalls dependencies, and launches the Tauri app
- [`backend/run-docker.sh`](https://github.com/Zackriya-Solutions/meetily/blob/main/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.