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

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 at the repository root and the Tauri-specific frontend/src-tauri/Cargo.toml. The Rust source entry point at 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, while the main React application logic resides in files like 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 – Defines the Rust workspace, feature flags, and crate dependencies for the backend.
• frontend/src-tauri/Cargo.toml – Configures the Tauri-specific Rust package with platform-specific dependencies.
• frontend/package.json – Lists npm packages, TypeScript/React dependencies, and build scripts for the UI.
• frontend/src-tauri/src/lib.rs – The Rust entry point that registers commands including start_recording.
• 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:

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:

#[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 for Rust dependencies and 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 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.

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