Meetily Dependencies: Complete Guide to Rust Crates and JavaScript Packages

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 powers Meetily's core functionality through several specialized crate categories.

Workspace Core Libraries

The root 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 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 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 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 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 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 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:

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:

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:

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

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

Summary

• Dual-stack architecture: Meetily dependencies split between Rust crates in Cargo.toml files and JavaScript packages in 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.
• 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 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 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, while application-specific Rust crates and Tauri plugins are declared in frontend/src-tauri/Cargo.toml. JavaScript dependencies for the Next.js frontend are listed in 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 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.

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