jamiepine/voicebox
40.1
Weak · 14 November 2026
51.7k
lines of production code
TypeScript
with Python, Rust
8
measurements over time
What this system is
Voicebox is a cross-platform desktop application built with Tauri and a Python backend that provides local text-to-speech generation, voice cloning, and system-wide dictation. It supports multiple TTS engines and audio capture across macOS, Windows, and Linux, featuring native integration for auto-paste dictation and system audio recording. The system includes a comprehensive UI for managing voice profiles, generation history, and audio effects, along with an MCP server for AI agent integration.
Features
Add native system audio capture for Linux and macOS
The application now supports capturing system-wide audio on Linux and macOS in addition to the existing Windows implementation. On Linux, it uses \pactl\ to detect PulseAudio/PipeWire monitor sources and selects the corresponding capture device via \cpal\, avoiding environment variable mutations. On macOS, it leverages the ScreenCaptureKit framework to capture desktop audio, requiring macOS 12.3 or newer. These changes are implemented in the \audio\_capture\ module (\linux.rs\, \macos.rs\, and updated \mod.rs\), providing a unified interface for system audio recording across all three supported platforms.
_tauri/src-tauri/src/audio\capture · high confidence
Add web platform abstraction layer
Introduces a new platform abstraction in the web frontend to decouple browser-specific logic from core application features. This change adds a \webPlatform\ implementation that provides no-op or browser-compatible behaviors for system audio capture, native device routing, filesystem access, server lifecycle management, and automatic updates, ensuring the application functions correctly in a web environment where these desktop capabilities are unavailable.
web/src/platform · high confidence
App interface now available in nine languages
The application's user interface has been localized into English, Spanish, French, Italian, Japanese, Korean, Brazilian Portuguese, Simplified Chinese, and Traditional Chinese. This change adds the necessary translation resources and configures the i18n foundation to automatically detect and apply the user's preferred language, ensuring that navigation, capture workflows, and settings are displayed in the user's native language.
app/src/i18n · high confidence
Expanded language support and new TTS engine options in generation requests
The backend API now accepts a wider range of languages (including Japanese, Korean, German, French, Russian, Portuguese, Spanish, Italian, Hebrew, Arabic, Danish, Greek, Finnish, Hindi, Malay, Dutch, Norwegian, Polish, Swedish, Swahili, and Turkish) for both voice profile creation and text generation. Additionally, the generation request model has been extended to support multiple TTS engines (Qwen, Qwen Custom Voice, Qwen Voice Design, LuxTTS, Chatterbox, Chatterbox Turbo, TADA, Kokoro, and OmniVoice), model size selection, personality-driven text refinement, chunked generation with crossfading, and post-processing audio effects chains.
voicebox-backend · high confidence
Generated TypeScript API client for voice profiles, generation, and capture
The app now includes a generated TypeScript API client in \app/src/lib/api\ (created via openapi-typescript-codegen) that provides type-safe wrappers for backend endpoints. This client exposes methods for managing voice profiles (create, list, update, delete, and sample management), triggering voice generation with personality-driven rewrite support, checking health and model status, and handling audio capture (dictation/recording) with refinement and auto-paste settings. It also includes core utilities like \CancelablePromise\ for request cancellation and robust error formatting, ensuring the frontend can interact with the backend's evolving API contract with full type safety.
app/src/lib/api · high confidence
Initial project scaffolding and release infrastructure
The repository is initialized with the core structure for the Voicebox application, including a Tauri-based desktop app, a Python backend, and a web frontend. This change introduces the release and build infrastructure: a \.bumpversion.cfg\ file to synchronize version numbers across the Tauri, web, and backend components, and a \Dockerfile\ with \docker-compose.yml\ (plus an ROCm overlay) to build and run the application in containers. It also adds essential configuration files such as \.dockerignore\, \.npmrc\ (enforcing Bun), \.gitattributes\, and an \.mcp.json\ example for the Model Context Protocol server, alongside standard documentation files like \CHANGELOG.md\, \CONTRIBUTING.md\, \LICENSE\, and \SECURITY.md\.
(repo-wide) · high confidence
Introduce local MCP server for AI agent integration
Adds a new Model Context Protocol (MCP) server to the backend, exposing Voicebox capabilities (text-to-speech, transcription, capture listing, and profile management) to local AI agents like Claude Code and Cursor. The server mounts at /mcp using Streamable HTTP transport, supports per-client voice profile bindings via the X-Voicebox-Client-Id header, and includes a stdio shim for legacy clients. Tool names use underscores to ensure compatibility with MCP client validation rules.
_backend/mcp\server · high confidence
Introduce native macOS auto-paste pipeline with platform-specific permission and input handling
This change adds the core Rust modules for a new auto-paste dictation feature on macOS, including accessibility and input-monitoring permission checks, system clipboard snapshot/restore, focused-window capture, global hotkey monitoring, and synthetic Cmd+V event posting. It also introduces cross-platform audio output and a background speak-monitor for agent-initiated audio playback. Users will see dictation results pasted directly into the active app, with proper handling of keyboard layouts and clipboard fidelity on macOS.
tauri/src-tauri/src · high confidence
Introduces core hooks for audio playback, recording, and dictation readiness
This change adds a suite of new React hooks in the \app/src/lib/hooks\ directory that power the application's audio and dictation capabilities. \useAudioPlayer\ manages playback state and cleanup, while \useAudioRecording\ handles microphone access, duration tracking, and WAV conversion. \useCaptureRecordingSession\ orchestrates the full capture lifecycle (record, transcribe, refine) with UI feedback via a 'pill' component, and \useChordSync\ manages the global hotkey monitor based on user settings. \useDictationReadiness\ acts as the single source of truth for checking if required models and system permissions (Input Monitoring, Accessibility) are ready before recording. Additionally, \useGenerationForm\ and \useGenerationProgress\ handle the TTS generation workflow, including model download tracking and SSE-based status updates, while \useRestoreActiveTasks\ ensures downloads and generations persist across page refreshes.
app/src/lib/hooks · high confidence
New audio channel management and enhanced playback state handling
The application now supports managing multiple audio output channels (including adding, updating, and removing them) via a new persistent store, giving users control over which devices are used for playback. The audio player store has been expanded to support looping, auto-play, and restart flags, allowing for more flexible playback behaviors. Additionally, a new story store centralizes playback timing and selection state, enabling precise seeking and resume capabilities within the track editor, while the UI store now persists theme preferences (including system mode) and voice profile draft states across sessions.
app/src/stores · high confidence
New auto-update and theme-sync hooks for Tauri apps
The app now includes dedicated React hooks to manage application updates and theme synchronization. The new \useAutoUpdater\ hook (available in both \.ts\ and \.tsx\ variants) integrates with the platform context to check for, download, and install updates on Tauri-based platforms. The \.tsx\ version provides a richer user experience by displaying toast notifications with progress bars when updates are available or downloading, and offers actions to update or restart the app immediately. The \useThemeSync\ hook automatically applies the selected theme (light, dark, or system) to the document root, listening for system preference changes when 'system' mode is selected.
app/src/hooks · high confidence
New backend services layer for generation, history, and cloud login
The backend now organizes core logic into a dedicated services layer, introducing new modules for generation orchestration (unified TTS pipeline with memory cleanup), history management (batched version queries to fix N+1 performance issues), cloud device login (browser-based OAuth flow with CSRF protection), and capture handling (STT transcript persistence). This refactoring also includes new services for audio channel management, effect presets, profile export/import, and personality-driven LLM composition, replacing previous inline implementations in main.py.
backend/services · high confidence
New backend utility modules for capture, TTS, audio processing, and system integration
This change introduces a suite of new utility modules in the backend to support core application features. It adds platform-specific hotkey chord definitions for voice capture, engine-agnostic chunked TTS generation with crossfade support, and a post-processing audio effects engine using the pedalboard library. System integration is improved with an ffmpeg wrapper for MP3/M4B exports, a lightweight shim for the descript-audio-codec dependency, and robust HuggingFace offline mode handling with download progress tracking. Additionally, it includes utilities for image processing (avatar uploads), platform detection for GPU backends, thread-safe progress and task management, and HTTP header helpers.
backend/utils · high confidence
New build, packaging, and release preparation scripts
The scripts directory now includes a comprehensive set of new automation tools: \convert-assets.sh\ optimizes documentation images by converting PNGs to WebP and MOVs to WebM; \package\_cuda.py\ and \package\_rocm.py\ split PyInstaller builds into smaller server cores and cached GPU runtime archives to improve update efficiency; \prepare-release.sh\ automates Tauri signing and release builds; \rocm-entrypoint.sh\ ensures proper GPU device permissions and data directory ownership in Docker; \setup-dev-sidecar.js\ generates placeholder binaries for Tauri development; \sync-higgs-tokenizer.py\ vendors and patches HuggingFace tokenizer code for compatibility; \test\_download\_progress.py\ provides debugging for HuggingFace model downloads; and \update-icons.sh\ generates platform-specific icons for macOS, Windows, iOS, and Android. Additionally, \build-server.sh\ was updated to build both the main server and MCP sidecars, and \generate-api.sh\ was changed to use port 17493 instead of 8000 for the local backend.
scripts · high confidence
New constants for TTS engine capabilities, language support, and UI safe areas
The application now centralizes configuration for voice generation and layout in new constant files. The \engines.ts\ module defines which TTS engines (Qwen CustomVoice, Qwen VoiceDesign, and OmniVoice) support the \instruct\ field, allowing the UI to correctly expose and handle instruction-based voice prompts. The \languages.ts\ module establishes a comprehensive mapping of supported languages for each engine (including Qwen, LuxTTS, Chatterbox, Kokoro, TADA, and OmniVoice) and provides helper functions to populate language selection dropdowns per engine. Additionally, \ui.ts\ introduces safe area padding constants to handle platform-specific layout adjustments, specifically accounting for macOS title bars and Windows drag regions, ensuring proper spacing around the audio player and window chrome.
app/src/lib/constants · high confidence
New dictation capture workflow with readiness checks and audio channel management
This change introduces the core UI components for the new dictation and capture features. It adds a Captures tab for managing recordings, a DictationReadinessChecklist to guide users through required model downloads and macOS Accessibility permissions, and a ChordPicker for configuring global keyboard shortcuts. It also introduces an AudioTab for managing audio output channels and devices, and a CapturePill for live status feedback during recording. Additionally, it includes an AudioKeepAlive component to prevent audio session teardown on macOS and a new AppFrame layout that conditionally renders the StoryTrackEditor or AudioPlayer.
app/src/components · high confidence
New utility modules for error handling, key codes, and audio processing
This update introduces several new utility modules in the app's core library. The \errorText\ module now condenses large server error messages for toast notifications, preserving the full original text for copying while displaying a truncated, readable head. The \keyCodes\ module provides a stable vocabulary for mapping browser keyboard events to canonical key names and display labels, supporting consistent chord persistence and UI rendering across platforms. Audio handling is enhanced with \getAudioDuration\ for accurate file duration detection (using Web Audio API to avoid VBR MP3 issues) and \convertToWav\ for format conversion. Additionally, \format.ts\ now supports internationalized date formatting with locale-aware distance and absolute date functions, and includes a mapping for engine display names.
app/src/lib/utils · high confidence
macOS audio capture, screen recording, and autoupdate support
The macOS build now requests microphone and screen-capture permissions, enabling users to record voice samples and system audio for voice cloning. The app also supports the macOS 11+ Overlay title bar style and includes an autoupdater configured to fetch updates from GitHub releases.
tauri/src-tauri · high confidence
Architecture
Extract shared QueryClient instance to a dedicated module
The shared React Query client configuration has been moved into a new, side-effect-free module (app/src/lib/queryClient.ts). This allows the client to be imported from both the React bootstrap entry point and non-React code (such as stores and utilities) without pulling in ReactDOM or other bootstrap side effects, improving modularity and decoupling.
app/src/lib · high confidence
Introduce Tauri platform abstraction layer
The application now uses a dedicated platform abstraction layer in the Tauri frontend to handle core capabilities. This change introduces specific implementations for audio capture and playback, file system operations (including save dialogs and directory picking), application lifecycle management (server start/stop/restart, window close handling, and server log subscriptions), automatic updates with progress tracking, and version metadata. This structure centralizes Tauri-specific API calls, replacing previous ad-hoc integrations with a consistent interface for these platform services.
tauri/src/platform · high confidence
Introduce platform abstraction layer for cross-platform capabilities
Added a new platform abstraction layer consisting of TypeScript interfaces and a React context provider. This change defines contracts for core capabilities including filesystem operations, update management, audio capture and playback, server lifecycle control, and platform metadata. The \PlatformContext\ allows application components to access these platform-specific implementations via a unified interface, enabling the app to support different backends (such as Tauri or CUDA) without hardcoding platform-specific logic.
app/src/platform · high confidence
Modularize backend routes into domain-specific routers
The monolithic route definitions in main.py have been extracted into a structured backend/routes directory, with each domain (such as generations, history, audio, captures, and cloud) now handled by its own dedicated router file. A new routes/\_\init\\_.py module centralizes the registration of all these routers onto the FastAPI application, improving code organization and maintainability without changing the external API surface.
backend/routes · high confidence
Unified backend abstraction layer for TTS and STT engines
The backend module has been restructured into a unified abstraction layer that standardizes how text-to-speech and speech-to-text engines are loaded, cached, and executed. This introduces a consistent protocol for TTS and STT backends, replacing scattered per-engine logic with shared utilities for device detection (including Intel XPU and AMD ROCm support), Hugging Face cache validation, and model download progress tracking. New backend implementations are provided for Chatterbox (PyTorch and MLX variants), HumeAI TADA, Kokoro, and LuxTTS, all adhering to the new interface. The MLX backend now enforces strict thread affinity via a dedicated single-worker executor to prevent Metal stream errors, while PyTorch backends use standardized device selection with explicit CPU fallback options. Model caching logic now correctly handles orphaned incomplete downloads and verifies required weight files before attempting offline loads.
backend/backends · high confidence
Behavioural changes
6 commits (1 fix) modifying tauri/src-tauri/icons
A change to existing behaviour in tauri/src-tauri/icons — 6 commits (1 fix), 32 files.
tauri/src-tauri/icons · medium confidence · unverified
App navigation and UI overhaul with new routing and theming
The app has been refactored to use @tanstack/react-router, replacing the previous tab-based interface with a sidebar-driven navigation system that includes dedicated pages for Captures, Effects, Stories, Voices, Models, and a multi-tab Settings area (General, Generation, Captures, MCP, GPU, Changelog, Logs, About). The UI theme has been updated to Tailwind CSS v4 syntax with a new color palette, and the entry point now imports i18n support and a centralized query client while removing the React Query devtools from production builds.
app/src · high confidence
Dark mode support and Vite build configuration updates
The Tauri entry point now supports dark mode by reading the user's theme preference from local storage and applying the 'dark' class to the document root, falling back to the system preference if no setting is found. Additionally, the Vite configuration has been updated to include a changelog plugin, adjust module resolution aliases, and configure file watching to ignore the target directory while monitoring the app source.
tauri · high confidence
Database layer restructured with SQLite performance optimizations and schema migrations
The database backend has been reorganized into a dedicated package, introducing a custom column-level migration system to handle schema evolution (such as replacing position-based ordering in story items with absolute timecodes and adding voice profile metadata) without external tools. SQLite performance is improved by enabling Write-Ahead Logging (WAL) and a 5-second busy timeout via a connection hook to prevent locking issues during concurrent access. The system also includes automatic data seeding for built-in effect presets and backfills generation versions for existing audio files.
backend/database · high confidence
Introduce React Query and Platform Context providers in the web entry point
The web application entry point (web/src/main.tsx) now wraps the root App component with React Query (via QueryClientProvider) and a PlatformContext (via PlatformProvider). This enables data caching and platform-specific behavior for the web frontend, configuring a 5-minute stale time, 10-minute garbage collection time, and single retry for queries.
web/src · high confidence
Introduce platform abstraction for Tauri integration
The application now wraps the main UI in a PlatformProvider, passing a tauriPlatform implementation to enable platform-specific behavior within the app. This change also disables the React Query Devtools in the production build by commenting out their import and usage.
tauri/src · high confidence
Settings overhaul and Vite build configuration updates
The application's settings interface has been restructured into routed sub-tabs, introducing new sections for server logs and a changelog view. To support the changelog feature, a new Vite plugin was added to expose the CHANGELOG.md file as a virtual module, and the Vite configuration was updated to include the Tailwind CSS Vite plugin. Additionally, the legacy tailwind.config.js file was removed, TypeScript configuration was adjusted to include Vite client types and plugin files, and a script was added to index.html to handle system-based dark mode theme resolution on load.
app · high confidence
Fixes
Fix frozen-binary imports for scipy and transformers
Added PyInstaller hooks for scipy.stats.\_distn\_infrastructure and transformers.masking\_utils to ensure their Python source files are bundled alongside bytecode. This change resolves NameError crashes in frozen binaries by allowing the runtime hook (pyi\_rth\_torch\_compiler\_disable.py) to successfully patch these modules at load time, which is required for correct torch.\_dynamo behavior.
_backend/pyi\hooks · high confidence
Fixes PyInstaller build crashes and AMD GPU detection on Windows
The backend now includes several PyInstaller runtime hooks to prevent frozen binary crashes: \pyi\_rth\_numpy\_compat.py\ patches \torch.from\_numpy\ to bypass ABI mismatches with numpy 2.x, \pyi\_rth\_torch\_compiler\_disable.py\ stubs \torch.\_dynamo\ to prevent import failures in transformers, and \pyi\_rth\_rocm\_sdk.py\ fixes library loading errors. Additionally, \app.py\ now automatically detects AMD GPUs and configures the \HSA\_OVERRIDE\_GFX\_VERSION\ environment variable for compatibility, while \server.py\ ensures the server process remains stable by handling broken pipes and managing the parent watchdog lifecycle.
backend · high confidence
Test coverage
Added integration test for system audio capture; Expanded backend test coverage for platform detection, audio validation, and API behavior.
Dependencies
Major dependency upgrades and platform-specific backend configuration
This update upgrades the application to version 0.6.0 and introduces significant dependency changes across the stack. The backend now requires Python 3.12 and pins specific versions for critical libraries like NumPy (\<2.0) and Numba to ensure compatibility, while adding support for ROCm (AMD GPUs) via new requirements files and MLX (Apple Silicon) with explicit miniaudio handling. The frontend and Tauri desktop app have been upgraded to use React 19, Tailwind CSS 4, and Tauri v2 plugins (dialog, fs, process, updater), alongside the addition of an MCP server for local AI agent integration and new audio capture capabilities on macOS, Windows, and Linux.
(dependencies) · high confidence
Written by cca.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.
How this codebase got here
Score
- CAI 41 → 40 (-1.0)
- Rubric changed (rubric-2026.10.5 → rubric-2026.11.4) — scores are not directly comparable.
Lenses
- Code Health 54 → 49 (-5.1)
- Architecture 89 → 89 (+0.0)
- Maturity 73 → 72 (-1.4)
- Readiness 20 → 23 (+3.2)
- Security 63 → 67 (+4.4)
- Accessibility 58 → 48 (-10.1)
- Performance 70 → 70 (+0.0)
Resolved (20)
- Duplicated block (10–11 lines × 2) (scripts/package_cuda.py)
- Duplicated block (14 lines × 2) (backend/services/cuda.py)
- Duplicated block (33 lines × 2) (backend/services/cuda.py)
- Duplicated block (5 lines × 3) (tauri/src-tauri/src/audio_capture/linux.rs)
- Duplicated block (7 lines × 2) (tauri/src-tauri/src/audio_capture/macos.rs)
- Duplicated block (9–10 lines × 2) (backend/database/migrations.py)
- Duplicated block (9–10 lines × 2) (backend/database/migrations.py)
- Duplicated block (9–10 lines × 2) (tauri/src-tauri/src/main.rs)
- Duplicated block (9–13 lines × 2) (backend/database/migrations.py)
- High CVE: [GHSA redacted] (bun.lock)
- High CVE: [GHSA redacted] (bun.lock)
- High CVE: [GHSA redacted] (bun.lock)
- High CVE: [GHSA redacted] (bun.lock)
- Hotspot: backend/backends/base.py (backend/backends/base.py)
- Hotspot: backend/services/cuda.py (backend/services/cuda.py)
- Medium CVE: PYSEC-2026-139 (backend/requirements-rocm.txt)
- Medium vulnerability: RUSTSEC-2026-0367 (tauri/src-tauri/Cargo.lock)
- Near-duplicate member pair (65 shared lines) (backend/services/cuda.py)
- No ADRs found
- Off-boarding risk: anonymized user #1
New (64)
- Critical CVE: [CVE redacted] (bun.lock)
- Critical CVE: [GHSA redacted] (tauri/src-tauri/Cargo.lock)
- Duplicated block (10–14 lines × 2) (tauri/src-tauri/src/main.rs)
- Duplicated block (11 lines × 3) (tauri/src-tauri/src/audio_output.rs)
- Duplicated block (5 lines × 3) (tauri/src-tauri/src/audio_capture/linux.rs)
- Duplicated block (6 lines × 2) (tauri/src-tauri/src/main.rs)
- Duplicated block (6 lines × 3) (tauri/src-tauri/src/main.rs)
- Duplicated block (6–7 lines × 2) (tauri/src-tauri/src/main.rs)
- Duplicated block (7 lines × 2) (tauri/src-tauri/src/audio_capture/macos.rs)
- Duplicated block (9–10 lines × 2) (tauri/src-tauri/src/main.rs)
- Edited copies of one member (3 members, 14+ corresponding lines) (backend/routes/audio.py)
- Edited copies of one member (3 members, 25+ corresponding lines) (backend/backends/pytorch_backend.py)
- Edited copies of one member (3 members, 31+ corresponding lines) (tauri/src-tauri/src/audio_capture/linux.rs)
- Edited copies of one member (3 members, 32+ corresponding lines) (backend/services/history.py)
- Edited copy of a member (10 corresponding lines) (backend/backends/luxtts_backend.py)
- Edited copy of a member (11 corresponding lines) (backend/backends/hume_backend.py)
- Edited copy of a member (11 corresponding lines) (backend/routes/effects.py)
- Edited copy of a member (13 corresponding lines) (backend/backends/mlx_backend.py)
- Edited copy of a member (13 corresponding lines) (backend/backends/mlx_backend.py)
- Edited copy of a member (14 corresponding lines) (backend/backends/mlx_backend.py)
- …and 44 more
Architecture
- Unchanged — 0 containers · 1 contexts · 0 edges
Written by cca.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.
Survey your own repository
jamiepine/voicebox was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.
About this page
- The score is its most recent published measurement, taken on 14 November 2026 at a pinned commit. It is not a live figure and does not change until the project is measured again.
- Measured at commit 8af7efe62fab8d33e2a5dfbedabaa45f68a5184f — the exact code this score is about.
- Scored under rubric-2026.11.4 — the same rubric and the same method as every other entry in this index.
- Measured by Canine Code Analyzer (cca.canine.dev) using cca measure-2026.11.65+preprod-e1a3b69fc8ee.