# Meetily Dependencies: Complete Guide to Rust Crates and JavaScript Packages

> Explore Meetily's hybrid Tauri app dependencies. Discover Rust crates for audio capture and AI transcription alongside JavaScript packages for the Nextjs frontend.

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

---

**Meetily is a hybrid Tauri desktop application that combines Rust backend crates for audio capture and AI transcription with JavaScript packages for its Next.js frontend interface.**

Meetily dependencies span two distinct runtime environments within the Zackriya-Solutions/meetily repository. The project uses a Rust workspace for native desktop functionality including real-time audio processing and Whisper-based speech recognition, while the frontend layer relies on modern React and Next.js libraries for UI rendering and state management.

## Rust Backend Dependencies

The Rust workspace defined in [`main/Cargo.toml`](https://github.com/Zackriya-Solutions/meetily/blob/main/main/Cargo.toml) powers Meetily's core functionality through several specialized crate categories.

### Workspace Core Libraries

The root [`Cargo.toml`](https://github.com/Zackriya-Solutions/meetily/blob/main/Cargo.toml) establishes shared foundations across all workspace members. **Any** provides ergonomic error handling throughout the async runtime, while **Serde** and **serde_json** handle configuration and IPC serialization. **Tokio** serves as the primary async runtime, enabling non-blocking I/O operations for audio streams and file processing.

### Tauri Framework and Plugins

The desktop shell in [`frontend/src-tauri/Cargo.toml`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/Cargo.toml) pulls in **tauri** along with its plugin ecosystem. Key plugins include `tauri-plugin-fs` for filesystem access, `tauri-plugin-store` for persistent settings, `tauri-plugin-notification` for OS-native alerts, and `tauri-plugin-single-instance` to prevent multiple app launches. The `tauri-plugin-updater` enables automatic update distribution, while `tauri-plugin-dialog` and `tauri-plugin-process` handle native UI dialogs and process management respectively.

### Audio Processing Pipeline

Real-time audio capture relies on **cpal** (Cross-platform Audio Library) for device enumeration and stream management. The pipeline in [`frontend/src-tauri/src/audio/pipeline.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/src/audio/pipeline.rs) utilizes **ringbuf** for lock-free buffering between capture and processing threads, **nnnoiseless** for real-time noise suppression, and **ebur128** for loudness normalization. **Symphonia** handles audio decoding, **rubato** performs sample rate conversion, and **rayon** enables parallel processing of audio chunks.

### AI and Transcription Engines

Speech-to-text functionality centers on **whisper-rs**, which wraps OpenAI's Whisper model with optional GPU acceleration features. The [`Cargo.toml`](https://github.com/Zackriya-Solutions/meetily/blob/main/Cargo.toml) defines conditional compilation for `metal` and `coreml` on macOS, `cuda` and `vulkan` on Windows/Linux, plus `hipblas` and `openblas` alternatives. **Ort** (ONNX Runtime) powers the alternative Parakeet transcription path, while **silero_rs** handles voice activity detection. The implementation 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) coordinates these backends.

### Async Utilities and System Integration

Concurrency tooling includes **futures-util** and **tokio-util** for stream combinators, **crossbeam** for lock-free queues, and **dashmap** for concurrent hash maps. **Uuid** generates unique meeting identifiers, **chrono** timestamps recordings, and **sqlx** manages the local SQLite database. **Tracing** provides structured logging throughout the Rust layer, while **sysinfo** captures system metrics for performance monitoring.

## JavaScript Frontend Dependencies

The Next.js interface in [`frontend/package.json`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/package.json) consumes a curated set of React ecosystem packages.

### UI Components and Styling

**Radix UI** primitives provide accessible, unstyled components for dialogs, dropdowns, and form controls. **Heroicons** and **Lucide React** supply consistent iconography, while **tailwindcss** with `tailwind-merge` and `clsx` handle utility-first styling. **Framer Motion** drives declarative animations for UI transitions, and **sonner** renders toast notifications.

### Rich Text Editing

The note-taking interface leverages **BlockNote** for block-based document editing with Markdown support. **Remirror** and **TipTap** extensions provide additional rich-text formatting capabilities, enabling hierarchical meeting notes alongside transcription segments.

### State Management and Form Handling

**React Hook Form** combined with **Zod** schemas manages meeting configuration and user settings with type-safe validation. **TanStack Virtual** optimizes rendering for long transcript lists, while **date-fns** handles temporal formatting and calculations.

## Platform-Specific GPU Features

The Rust backend uses conditional compilation to enable hardware acceleration where available. The [`frontend/src-tauri/Cargo.toml`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/Cargo.toml) specifies `[target.'cfg(...)'.dependencies]` blocks that activate Metal/CoreML on Apple Silicon, CUDA on NVIDIA hardware, and Vulkan as a cross-platform fallback. These features gates ensure optimal transcription performance without bundling incompatible binaries.

## Using Meetily Dependencies in Practice

The following examples demonstrate how these libraries integrate across the stack.

Accessing the Whisper engine from Rust:

```rust
use whisper_rs::{Whisper, WhisperContext};

async fn transcribe(audio: &[f32]) -> anyhow::Result<String> {
    // whisper-rs is declared with GPU-specific features in Cargo.toml
    let model_path = "/path/to/model.bin";
    let whisper = Whisper::new(&model_path)?;
    let mut ctx = WhisperContext::new(&whisper)?;
    let result = ctx.transcribe(audio).await?;
    Ok(result.text)
}

```

Invoking Rust commands from the Next.js frontend:

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

async function startRecording(meetingName: string) {
  // The Rust command `start_recording` is exposed in src-tauri/src/lib.rs
  await invoke<void>('start_recording', {
    micDeviceName: 'Built‑in Microphone',
    systemDeviceName: 'BlackHole 2ch',
    meetingName,
  });
}

```

Rendering the BlockNote editor component:

```tsx
import { BlockNoteEditor } from '@blocknote/react';

export default function NoteEditor() {
  return <BlockNoteEditor />;
}

```

## Summary

- **Dual-stack architecture**: Meetily dependencies split between Rust crates in [`Cargo.toml`](https://github.com/Zackriya-Solutions/meetily/blob/main/Cargo.toml) files and JavaScript packages in [`frontend/package.json`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/package.json).
- **Audio processing**: **cpal**, **ringbuf**, **nnnoiseless**, and **rubato** handle capture, buffering, noise reduction, and resampling in [`frontend/src-tauri/src/audio/pipeline.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/src/audio/pipeline.rs).
- **AI transcription**: **whisper-rs** with conditional GPU features (`metal`, `cuda`, `vulkan`) and **ort** for ONNX-based alternatives.
- **Desktop shell**: **tauri** with plugins for filesystem, notifications, updates, and single-instance guarding.
- **Frontend stack**: Next.js with **Radix UI**, **BlockNote**, **React Hook Form**, and **Tailwind CSS** for the meeting interface.

## Frequently Asked Questions

### What GPU backends does Meetily support for transcription?

Meetily supports Metal and CoreML on macOS, CUDA and Vulkan on Windows and Linux, plus OpenBLAS and HIPBLAS for AMD hardware. These are configured as optional features in [`frontend/src-tauri/Cargo.toml`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/Cargo.toml) under conditional target dependencies, allowing optimized builds for specific hardware without including incompatible libraries.

### How does the audio pipeline manage its Rust dependencies?

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) coordinates **cpal** for device access, **ringbuf** for inter-thread communication, **nnnoiseless** for noise suppression, and **ebur128** for loudness normalization. **Rayon** parallelizes processing tasks, while **symphonia** and **rubato** handle format conversion and resampling respectively.

### Where are the main dependency configuration files located?

Workspace-level Rust dependencies reside in [`main/Cargo.toml`](https://github.com/Zackriya-Solutions/meetily/blob/main/main/Cargo.toml), while application-specific Rust crates and Tauri plugins are declared in [`frontend/src-tauri/Cargo.toml`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/Cargo.toml). JavaScript dependencies for the Next.js frontend are listed in [`frontend/package.json`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/package.json). These three files define the complete dependency graph for the project.

### Can Meetily run without all JavaScript development dependencies?

Yes. The [`package.json`](https://github.com/Zackriya-Solutions/meetily/blob/main/package.json) separates `dependencies` (required for runtime) from `devDependencies` (build tools and type definitions). Production builds only bundle the runtime dependencies plus the compiled Rust binary. However, `@tauri-apps/api` and the plugin packages are required at runtime for frontend-to-backend communication.