# What Programming Language Is Meetily Written In? A Deep Dive into the Hybrid Stack

> Discover what programming language Meetily uses. Explore its hybrid stack of Rust for performance and TypeScript for its desktop interface.

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

---

**Meetily is written in Rust and TypeScript**, combining a Rust backend for high-performance audio processing with a TypeScript/React frontend for the desktop user interface.

Meetily is a hybrid desktop application developed by Zackriya-Solutions that leverages a dual-language architecture. Understanding what programming language Meetily is written in requires examining both its performance-critical backend and its modern user interface layer. The codebase is fundamentally split between Rust for system-level operations and TypeScript for the frontend experience.

## The Dual-Language Architecture

Meetily employs a strategic separation of concerns where each language handles what it does best. This architecture delivers a privacy-first, native-feel application with low-latency audio capabilities.

### Rust: The Performance-Critical Backend

The core backend functionality is implemented in **Rust**, compiled to a static library and exposed to the frontend via Tauri commands. Rust handles all performance-sensitive operations including audio capture, GPU-accelerated Whisper transcription, and cross-platform system integration.

Key Rust configuration files include the workspace-level [`Cargo.toml`](https://github.com/Zackriya-Solutions/meetily/blob/main/Cargo.toml) at the repository root and the Tauri-specific [`frontend/src-tauri/Cargo.toml`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/Cargo.toml). The Rust source entry point at [`frontend/src-tauri/src/lib.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/src/lib.rs) registers Tauri commands and initializes the native backend.

### TypeScript: The React-Based Frontend

The user interface layer is built with **TypeScript** (and JavaScript) running inside a Next.js/React environment. This frontend operates within the Tauri window, managing state, rendering components, and handling all UI logic.

The frontend dependencies and build configuration are defined in [`frontend/package.json`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/package.json), while the main React application logic resides in files like [`frontend/src/app/page.tsx`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src/app/page.tsx), which handles recording triggers and transcript displays.

## Key Repository Files That Reveal the Stack

The following files definitively answer what programming language Meetily is written in:

- **[`Cargo.toml`](https://github.com/Zackriya-Solutions/meetily/blob/main/Cargo.toml)** – Defines the Rust workspace, feature flags, and crate dependencies for the backend.
- **[`frontend/src-tauri/Cargo.toml`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/Cargo.toml)** – Configures the Tauri-specific Rust package with platform-specific dependencies.
- **[`frontend/package.json`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/package.json)** – Lists npm packages, TypeScript/React dependencies, and build scripts for the UI.
- **[`frontend/src-tauri/src/lib.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/src/lib.rs)** – The Rust entry point that registers commands including `start_recording`.
- **[`frontend/src/app/page.tsx`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src/app/page.tsx)** – The TypeScript React component that initiates recordings and displays meeting transcripts.

## How Rust and TypeScript Communicate

The two languages interact through Tauri's IPC layer, allowing the TypeScript frontend to invoke Rust-implemented commands.

Here is how the frontend calls a Rust command to start recording:

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

async function startMeeting() {
  try {
    await invoke('start_recording', {
      mic_device_name: 'Built‑in Microphone',
      system_device_name: 'BlackHole 2ch',
      meeting_name: 'Team Sync',
    });
    console.log('Recording started');
  } catch (e) {
    console.error('Failed to start recording', e);
  }
}

```

And here is the corresponding Rust implementation that receives this call:

```rust
#[tauri::command]
async fn start_recording(
    app: tauri::AppHandle,
    mic_device_name: Option<String>,
    system_device_name: Option<String>,
    meeting_name: Option<String>,
) -> Result<(), String> {
    // Delegates to the audio pipeline; errors are turned into strings for the UI
    audio::recording_commands::start(
        app,
        mic_device_name,
        system_device_name,
        meeting_name,
    )
    .await
    .map_err(|e| e.to_string())
}

```

This RPC mechanism allows Meetily to maintain Rust's performance advantages while providing the developer experience of a modern React application.

## Summary

- **Meetily is written in Rust and TypeScript**, utilizing a hybrid architecture via the Tauri framework.
- **Rust handles** audio capture, GPU-accelerated Whisper transcription, and system-level operations in the `src-tauri` directory.
- **TypeScript drives** the Next.js/React frontend, managing UI state and component rendering in the `frontend` directory.
- **Communication** between layers occurs through Tauri commands, with TypeScript invoking Rust functions via the `@tauri-apps/api` library.
- **Key configuration files** include [`Cargo.toml`](https://github.com/Zackriya-Solutions/meetily/blob/main/Cargo.toml) for Rust dependencies and [`package.json`](https://github.com/Zackriya-Solutions/meetily/blob/main/package.json) for TypeScript/JavaScript dependencies.

## Frequently Asked Questions

### Is Meetily built with Electron?

No, Meetily uses **Tauri**, not Electron. While Electron relies on Node.js and Chromium, Tauri utilizes a Rust backend with a lightweight WebView frontend, resulting in smaller bundle sizes and lower memory consumption. The Rust core in [`frontend/src-tauri/src/lib.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/src/lib.rs) replaces the Node.js backend typical of Electron apps.

### Why does Meetily use Rust instead of Node.js for audio processing?

Rust provides **memory safety without garbage collection** and **zero-cost abstractions**, making it ideal for low-latency audio processing and real-time transcription. The `start_recording` command in the Rust layer can interface directly with system audio APIs and GPU acceleration for Whisper models, performance characteristics that are harder to achieve with Node.js alone.

### What frontend framework does Meetily use?

Meetily uses **Next.js with React**, written in TypeScript. The UI components reside in the `frontend/src/app/` directory, following modern React patterns for state management and rendering. This choice allows the application to leverage the vast React ecosystem while running inside the Tauri desktop container.

### Can I contribute to Meetily if I only know TypeScript?

Yes, you can contribute to the **UI layer** using TypeScript, React, and Next.js knowledge found in the `frontend/` directory. However, backend features involving audio processing, transcription logic, or native system integration require Rust knowledge, as implemented in the `frontend/src-tauri/src/` directory.