Handy is a free, open-source, offline speech-to-text desktop application built with Tauri (Rust backend + React/TypeScript frontend). It records microphone audio, transcribes using local ASR models (Whisper, Parakeet, etc.), and pastes the text into any active application via global shortcuts. The architecture is a monolith with a single-process Rust backend that manages audio capture, VAD (Silero), model loading (GGUF/ONNX), transcription engines (transcribe-cpp, transcribe-rs), clipboard paste, system tray, and recording overlays. The frontend is a React SPA that communicates with the backend via Tauri commands and events, providing a rich settings UI, model management, onboarding, history, and post-processing via OpenAI-compatible LLM APIs or Apple Intelligence. The codebase exhibits high craftsmanship with extensive use of RAII guards, lock-free streaming, state machines, platform-specific abstractions, and thorough error handling. It is actively maintained with frequent commits, a large community, and cross-platform builds for macOS, Windows, and Linux, including Nix support.
VidBee is a multi-platform media downloader and transcript workspace. The primary product is an Electron desktop app that downloads video/audio from 1000+ sites via yt-dlp, runs local speech-to-text transcription (sherpa-onnx Whisper/SenseVoice/Qwen3/Parakeet families) with speaker diarization in an isolated worker process, and provides an AI agent chat, summarization, translation, and FAQ layer over the resulting transcripts. It also ships a self-hosted Fastify API with a TanStack Start web client, a CLI wrapper around yt-dlp that can run fully in-process or connect to the desktop/API, and a browser extension (WXT) that hands video URLs to the desktop app via a token-authenticated loopback HTTP bridge. An RSS subscription engine with SQLite CAS leader election supports feed auto-download. Architecturally this is a pnpm monorepo built around host-neutral packages: packages/task-queue (FSM-driven job queue with priority scheduler, retry backoff, watchdog, and SQLite/memory persistence adapters), packages/transcription (ASR pipeline, caption parsing, speaker clustering, chunk manifests), packages/downloader-core (yt-dlp args, format selection, cookie handling, oRPC contracts), packages/subscriptions-core (feed parsing, scheduler, leader election), plus packages/ui, packages/i18n, packages/db, and packages/logger. The desktop, API, CLI, and web hosts share these packages, and oRPC contract schemas are explicitly kept byte-equal across hosts. The desktop renderer uses React 19, TanStack Router, Jotai, and Tailwind 4; the main process uses an IPC-decorator pattern with roughly fifteen typed services. Engineering quality is consistently above average: shared contracts with zod validation, swappable persistence adapters, a pure-function task FSM, security-conscious extension token auth, and an SSRF-guarded remote image proxy. The main weaknesses are duplication and sync fragility: near-identical download UI components exist in both desktop and web apps, several overlapping error classifiers must be kept manually in sync, the API hardcodes APP_VERSION separately from package versions, and legacy migration/back-compat paths (task-queue projection to legacy DownloadItem shapes, migrate-history scripts) accumulate complexity. This is an application repository, not data research: the ASR and speaker-clustering code is product engineering rather than a research artifact, though the transcription package is a genuinely reusable pipeline.
SenseVoice is a production-grade speech understanding application built around the SenseVoiceSmall encoder-only model. It provides automatic speech recognition (ASR), language identification, speech emotion recognition (SER), and audio event detection (AED) via a non-autoregressive CTC pipeline. The Python codebase includes a FastAPI inference server, Gradio web UI, ONNX/Libtorch export utilities, a long-audio inference script with bounded memory, and a fine-tuning workflow backed by DeepSpeed. The repository also ships an independent C++ runtime under `runtime/llama.cpp/` that ports the same model to GGUF format for CPU/edge deployment without Python. While the core model (`model.py`) is a thin wrapper around the FunASR library and tightly coupled to its conventions, supporting utilities like CTC forced alignment, device resolution, and SER evaluation are well-isolated and reusable. The llama.cpp C++ components (VAD, SenseVoice decoder, and an OpenAI-compatible streaming server) are self-contained, architecturally clean, and validated against the PyTorch reference, making them the highest-value reusable assets. The project is actively maintained with recent commits, thorough tests, and CI/CD for both container builds and the C++ runtime.
chubbyskills is a personal knowledge management CLI toolkit that ingests content from over a dozen platforms (YouTube, Bilibili, X, Xiaohongshu, WeChat, Douyin, Podcasts, etc.), transcribes audio/video locally or via cloud providers, and outputs structured Markdown notes with YAML frontmatter (schema v1). The system is architected as a collection of modular "skills" (one per platform) orchestrated by a unified CLI (`tools/chubby.py`), with shared utilities in `chubby_common/`. It includes an incremental knowledge base indexer using SQLite FTS5 and optional semantic embeddings, an MCP server exposing six tools for AI agent integration, and a deterministic evidence brief generator with integrity validation. Operation is local-first: transcription uses SenseVoice and faster-whisper, video downloading uses yt-dlp, and all processing is designed to work offline. Cloud transcription (Atlas/MuAPI) and LLM enrichment (DeepSeek) are optional extensions. The repository also provides a skill installer, platform smoke testing, output validation, and retry mechanisms with credential redaction. Despite the breadth, the codebase maintains clean separation of concerns, with the shared library standing out as a reusable zero-dependency core.
Parakeet.cpp is a high-performance speech recognition inference library for NVIDIA's Parakeet model family (TDT-CTC, RNNT, Streaming EOU, Nemotron, Sortformer), written in C++ with C bindings. It provides offline and streaming transcription, speaker diarization, voice activity detection (VAD), beam search with optional n-gram language model fusion, phrase boosting, and timestamp extraction. The library is built on the axiom tensor library with Metal GPU acceleration for Apple Silicon, and supports audio input from WAV, FLAC, MP3, and OGG formats. The codebase includes a CLI tool, a Unix domain socket server example, and a rich set of examples covering all major features. While primarily an application/library for production ASR inference, it also contains research-oriented model conversion scripts (NeMo to safetensors) and a benchmark script comparing with PyTorch inference, giving it a hybrid character. The architecture is cleanly modular, with separate modules for audio I/O, VAD, model encoders/decoders, and decoding algorithms. The C API enables binding to Python, Swift, Rust, and other languages. Documentation and build system are well-maintained, and the repository is actively developed with recent commits.
Swabble is a macOS 26 CLI daemon and Swift library that listens to the microphone, detects a configurable wake word (default 'clawd'), transcribes speech locally using Apple's Speech.framework (SpeechAnalyzer + SpeechTranscriber), and executes a user-defined shell hook with the transcript. It also supports offline file transcription to TXT or SRT. The architecture is a monolith Swift package with a library target (SwabbleCore) exposing reusable components like the speech pipeline, hook runner, config loader, and transcript store, and an executable target (SwabbleCLI) using the Commander library for command routing. Key data flows: microphone audio → AVAudioEngine tap → BufferConverter → SpeechAnalyzer → SpeechTranscriber → async stream → wake-word matching → HookRunner → shell process. External dependencies are limited to Apple frameworks and the Commander package. The codebase demonstrates strong use of Swift 6.2 concurrency (actors, async streams), careful process management with timeout and cancellation, and clean separation of concerns. It is well-tested with CI covering formatting, linting, unit tests, and release verification.
diart is a Python library and CLI tool for real-time online speaker diarization, built on top of pyannote.audio. It processes audio streams (microphone, files, WebSocket) with low latency using a modular pipeline of segmentation, embedding, clustering, and aggregation blocks. The library is designed for both streaming and offline evaluation, with support for overlap-aware processing and hyperparameter tuning via Optuna. It provides a reactive streaming architecture using RxPY, making it suitable for building AI-powered audio applications. The repository includes a benchmark suite, expected outputs for standard diarization datasets (AMI, DIHARD, VoxConverse), and CI/CD pipelines. While primarily a software library, it has a strong research component with published results and reproducibility artifacts.
Voquill is a cross-platform voice dictation and AI transcription application that allows users to dictate into any application with real-time speech recognition, AI post-processing, and an agent mode for automated tasks. The desktop app (Tauri + Rust + React) provides a native overlay, global hotkeys, and multiple transcription backends (local Whisper, cloud providers, enterprise). The enterprise edition includes a gateway service with PostgreSQL, admin panel, OIDC SSO, and custom STT/LLM providers. Mobile apps (Flutter) with keyboard extensions provide dictation on iOS and Android. The CLI tool offers headless dictation and agent functionality. The architecture is a monorepo with shared packages for types, utilities, voice AI integrations, and agent loop, demonstrating a well-structured, multi-platform application with significant hybrid characteristics due to extensive data pipelines for transcription and model management.