# Dependencies for the Meetily Project: Complete Guide to Rust, Node.js, and Legacy Python Libraries

> Discover the Meetily project's dependencies. Explore Rust, Node.js, and legacy Python libraries used in this essential guide.

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

---

**The Meetily project declares its core third-party libraries in [`frontend/src-tauri/Cargo.toml`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/Cargo.toml) for Rust, [`frontend/package.json`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/package.json) for the Next.js frontend, and retains an archived [`backend/requirements.txt`](https://github.com/Zackriya-Solutions/meetily/blob/main/backend/requirements.txt) for historical Python dependencies.**

Meetily, maintained by Zackriya-Solutions, is a Tauri-based desktop application that combines a Rust backend with a Next.js/TypeScript frontend to deliver local meeting transcription and summarization. Understanding the dependencies for the Meetily project is essential for anyone building from source, contributing to the audio pipeline, or auditing the technology stack. The following sections break down each manifest, highlight the most critical crates and packages, and show exactly how they are used in the source code.

## Rust (Tauri) Dependencies Declared in [`Cargo.toml`](https://github.com/Zackriya-Solutions/meetily/blob/main/Cargo.toml)

The native desktop runtime is controlled by [`frontend/src-tauri/Cargo.toml`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/Cargo.toml). According to the Meetily source code, this manifest defines the async runtime, audio I/O, speech-to-text engine, local database bindings, and serialization crates required by the backend.

```toml

# frontend/src-tauri/Cargo.toml  (excerpt)

[dependencies]
tauri = { version = "2", features = ["api-all"] }          # Core Tauri framework

tokio = { version = "1", features = ["full"] }            # Async runtime

serde = { version = "1", features = ["derive"] }          # (De)serialization

anyhow = "1"                                               # Error handling convenience

log = "0.4"                                                # Logging facade

env_logger = "0.10"                                       # Simple logger implementation

cpal = "0.15"                                             # Cross‑platform audio I/O

whisper-rs = "0.1"                                        # Whisper transcription wrapper

serde_json = "1"                                          # JSON handling

chrono = { version = "0.4", features = ["serde"] }       # Date‑time utilities

sqlx = { version = "0.7", features = ["sqlite", "runtime-tokio-rustls"] } # Async DB

rusqlite = "0.29"                                         # SQLite bindings (fallback)

serde_yaml = "0.9"                                        # YAML parsing (config)

# … plus a few optional dev‑only crates such as

test‑case = "2"

```

These crates give Meetily its essential backend capabilities:

- **Tauri** — Bridges the Rust core to the webview UI via IPC commands and events.
- **Tokio** — Powers the concurrent audio capture, VAD processing, and Whisper transcription pipelines.
- **Cpal** — Abstracts microphone and system-audio capture across macOS, Windows, and Linux.
- **Whisper-rs** — Runs the local Whisper model for on-device speech-to-text.
- **SQLx / Rusqlite** — Stores meetings, transcripts, and summary data locally in SQLite.
- **Serde, Serde-json, and Serde-yaml** — Handle configuration files, command payloads, and persisted data.

## Node.js Frontend Dependencies Declared in [`package.json`](https://github.com/Zackriya-Solutions/meetily/blob/main/package.json)

The React UI layer tracks its requirements inside [`frontend/package.json`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/package.json). These dependencies supply the build toolchain, UI utilities, state container, and HTTP client that the frontend uses to communicate with the Rust core.

```json
// frontend/package.json (excerpt)

{
  "dependencies": {
    "next": "14.x",                // React‑based web framework
    "react": "18.x",
    "react-dom": "18.x",
    "@tauri-apps/api": "^2.0.0",   // Front‑end wrapper for Tauri commands/events
    "typescript": "^5.2.0",
    "tailwindcss": "^3.4.0",      // UI styling utilities
    "zustand": "^4.5.0",           // Simple global state management (used by SidebarProvider)
    "clsx": "^2.0.0",              // Conditional className helper
    "axios": "^1.7.0",             // HTTP client (used for remote LLM calls to Ollama, Groq, etc.)
    "uuid": "^10.0.0"              // Unique identifiers for meetings and recordings
  },
  "devDependencies": {
    "eslint": "^8.57.0",
    "prettier": "^3.2.5",
    "tailwindcss": "^3.4.0",
    "typescript": "^5.2.0",
    "jest": "^29.7.0",
    "ts-jest": "^29.1.2"
  }
}

```

Key roles of these packages include:

- **@tauri-apps/api** — Lets the React UI invoke Rust commands such as `start_recording` and subscribe to backend events.
- **Next.js** — Serves the UI locally during development and bundles it for the Tauri desktop build.
- **Tailwind CSS** — Provides the utility-first styling used throughout the application.
- **Zustand** — Lightweight state container that powers global UI state, including the `SidebarProvider`.
- **Axios** — Performs outbound LLM requests to local Ollama instances or remote endpoints after transcription completes.

## Legacy Python Backend Dependencies

The Python FastAPI backend located in `backend/` is archived and no longer used by the current Meetily release. Its dependency list remains available in [`backend/requirements.txt`](https://github.com/Zackriya-Solutions/meetily/blob/main/backend/requirements.txt) for historical reference only, and you can safely ignore it for any new development or production build.

## Practical Code Examples Using Meetily Dependencies

### Invoking a Rust Command from the React UI

The frontend uses `@tauri-apps/api` to call the `start_recording` command registered in [`frontend/src-tauri/src/lib.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/src/lib.rs).

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

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

```

### Listening for Transcript Updates Emitted by Rust

The audio pipeline in [`frontend/src-tauri/src/audio/pipeline.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/src/audio/pipeline.rs) emits `transcript-update` events that the frontend captures with `@tauri-apps/api/event`.

```typescript
import { listen } from '@tauri-apps/api/event';
import type { TranscriptUpdate } from '@/types';

listen<TranscriptUpdate>('transcript-update', (event) => {
  const { text, timestamp } = event.payload;
  console.log(`[${timestamp}] ${text}`);
  // Update UI state (e.g., via Zustand or React setState)
});

```

### Performing a Remote LLM Request After Transcription

After transcription, the frontend uses **axios** to send the transcript to a local or remote LLM endpoint.

```typescript
import axios from 'axios';

async function summarize(text: string) {
  const resp = await axios.post(
    'http://localhost:11434/api/generate',
    {
      model: 'llama3',
      prompt: `Summarize the following meeting transcript:\n${text}`,
    },
    { headers: { 'Content-Type': 'application/json' } }
  );
  return resp.data.response;
}

```

## Key Source Files That Rely on These Dependencies

The following files consume the crates and packages listed above:

- [`frontend/src-tauri/src/lib.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/src/lib.rs) — Registers all Tauri commands (for example, `start_recording`) and bootstraps the application.
- [`frontend/src-tauri/src/audio/pipeline.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/src/audio/pipeline.rs) — Orchestrates audio mixing, VAD filtering, and emits `transcript-update` events.
- [`frontend/src-tauri/src/audio/recording_manager.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/src/audio/recording_manager.rs) — Coordinates capture streams and persists raw recordings.
- [`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) — Loads the Whisper model and executes STT inference via `whisper-rs`.
- [`frontend/src-tauri/Cargo.toml`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/Cargo.toml) — Lists every Rust crate required for the native backend.
- [`frontend/package.json`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/package.json) — Lists every Node.js package required for the React frontend.
- [`backend/requirements.txt`](https://github.com/Zackriya-Solutions/meetily/blob/main/backend/requirements.txt) — Archived Python requirements kept for historical context; not used by the current app.

## Summary

- Meetily's active third-party libraries are declared in [`frontend/src-tauri/Cargo.toml`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/Cargo.toml) (Rust) and [`frontend/package.json`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/package.json) (Node.js).
- The Rust backend depends on **Tauri**, **Tokio**, **cpal**, **whisper-rs**, **SQLx**, and **Rusqlite** to handle desktop windowing, async tasks, audio capture, transcription, and local SQLite storage.
- The Next.js frontend relies on **@tauri-apps/api**, **Next.js**, **Tailwind CSS**, **Zustand**, and **Axios** to render the UI, manage state, and communicate with external LLM services.
- The [`backend/requirements.txt`](https://github.com/Zackriya-Solutions/meetily/blob/main/backend/requirements.txt) Python dependency list is archived and is not required for current Meetily builds.

## Frequently Asked Questions

### What are the main dependencies for the Meetily project?

The main dependencies are declared in two active manifest files. [`frontend/src-tauri/Cargo.toml`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/Cargo.toml) manages Rust crates such as `tauri`, `tokio`, `cpal`, and `whisper-rs`, while [`frontend/package.json`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/package.json) manages Node.js packages including `next`, `@tauri-apps/api`, `zustand`, and `axios`.

### How does the React frontend communicate with the Rust backend?

It uses `@tauri-apps/api` to invoke commands registered in [`frontend/src-tauri/src/lib.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/src/lib.rs) and to listen for events emitted by the Rust audio pipeline. This IPC layer lets the webview trigger native operations like recording start and receive real-time transcript updates without direct file system access.

### Is the Python backend required to run Meetily?

No. The Python FastAPI backend inside `backend/` is archived and not used by the current release. Its [`backend/requirements.txt`](https://github.com/Zackriya-Solutions/meetily/blob/main/backend/requirements.txt) remains in the repository only for historical reference, and the modern application runs entirely on the Rust Tauri core and the Next.js frontend.

### Which Rust crate handles speech-to-text transcription?

The Rust backend uses `whisper-rs` to load and run the local Whisper model for speech-to-text, as 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). Supporting crates such as `cpal` manage audio input, while `tokio` schedules the asynchronous inference pipeline.