Skip to content
BranchesTags

Repository files navigation

Higgs Audio v3 Studio

Platform GPU UI Backend Engine Build

中文说明 | Linux branch

Higgsv3tts-cpp.mp4

Author: Saganaki22

Higgs Audio v3 Studio 0.3.0 is a Windows desktop app built with Rust/Tauri for local Higgs Audio v3 TTS inference through a ported native C++/CUDA engine. The app does not shell out to a CLI sidecar: the Tauri UI calls Rust commands, Rust loads audiocpp_engine.dll with libloading, and the DLL executes the native inference path through a small C ABI.

This main branch tracks the Windows desktop release. Linux .deb and AppImage builds are available from the same GitHub Releases page and are built from the linux branch.

The goal is simple: a practical desktop workflow for local TTS, voice cloning, speech continuation, and multi-speaker generation without making users manage a Python environment.

Downloads

Prebuilt packages are published from:

Direct runtime downloads:

File Recommended VRAM Direct link
Engine DLL package NVIDIA CUDA 13 GPU/driver required https://huggingface.co/drbaph/Higgs-Audio-v3-Studio/tree/main/engines
Linux engine package NVIDIA CUDA 13 GPU/driver required https://huggingface.co/drbaph/Higgs-Audio-v3-Studio/tree/main/engines_linux
Higgs Q8_0 recommended 12 GB VRAM https://huggingface.co/drbaph/Higgs-Audio-v3-Studio/resolve/main/models/higgs-q8_0/q8_0.gguf
Higgs Q6_K 10 GB VRAM https://huggingface.co/drbaph/Higgs-Audio-v3-Studio/resolve/main/models/higgs-q6_k/q6_k.gguf
Higgs Q5_K 9 GB VRAM https://huggingface.co/drbaph/Higgs-Audio-v3-Studio/resolve/main/models/higgs-q5_k/q5_k.gguf
Higgs Q4_K_M 8 GB VRAM https://huggingface.co/drbaph/Higgs-Audio-v3-Studio/resolve/main/models/higgs-q4_k_m/q4_k_m.gguf
Higgs BF16 16 GB VRAM https://huggingface.co/drbaph/Higgs-Audio-v3-Studio/resolve/main/models/higgs-bf16/bf16.gguf

Recommended user flow:

  1. Download the latest Windows release from GitHub. Linux users should download the .deb or AppImage from the same Releases page.
  2. Launch Higgs Audio v3 Studio.
  3. Click Download Engine DLLs on Windows, or Download Engine Files on Linux, if the engine package is not installed.
  4. Download or browse to a Higgs model folder. In-app Higgs downloads fetch the whole selected folder: GGUF weights plus config/tokenizer/chat-template assets.
  5. Click Load Engine, then Load Model.
  6. Pick a workflow and generate audio.
Hugging Face repository layout

The Hugging Face repository root should contain manifest.json directly at the top level. Put it beside models/, engines/, and checksums/:

drbaph/Higgs-Audio-v3-Studio/
  manifest.json
  engines/
    audiocpp_engine.dll
    cublas64_13.dll
    cublasLt64_13.dll
    VCOMP140.DLL
    MSVCP140.dll
    VCRUNTIME140.dll
    VCRUNTIME140_1.dll
  engines_linux/
    libaudiocpp_engine.so
    libcudart.so.13
    libcublas.so.13
    libcublasLt.so.13
  models/
    higgs-q8_0/
      q8_0.gguf
      config/tokenizer/chat-template assets
    higgs-q6_k/
      q6_k.gguf
      config/tokenizer/chat-template assets
    higgs-q5_k/
      q5_k.gguf
      config/tokenizer/chat-template assets
    higgs-q4_k_m/
      q4_k_m.gguf
      config/tokenizer/chat-template assets
    higgs-bf16/
      bf16.gguf
      config/tokenizer/chat-template assets
  checksums/
    SHA256SUMS.txt

Upload your local Hugging Face staging folder with this same structure to the Hugging Face repo root so the runtime links resolve under /resolve/main/....

What It Does

  • Runs the ported Higgs Audio v3 C++/CUDA engine inside a Tauri desktop app.
  • Supports normal TTS, voice cloning, speech continuation, and multi-speaker workflows.
  • Supports reference voice drag/drop, replacement, waveform previews, remove buttons, and automatic 30-second reference preparation for voice cloning and Speaker Gallery uploads.
  • Records reference voices directly from a selected microphone in Voice Clone, Continue Speech, Speaker Gallery, and each Multi Speaker voice card, with a live waveform, stop/replace controls, and a 30-second safety limit.
  • Trims reference audio with selectable start/end points and selection playback in Voice Clone, Continue Speech, Speaker Gallery, Multi Speaker identities, and line-specific overrides; applying a trim replaces the actual Higgs/Whisper input and invalidates stale speaker caches.
  • Decodes Telegram/WhatsApp OGG/Opus and WebM/Opus reference audio natively, without requiring FFmpeg or an external codec installation.
  • Supports optional live streaming playback during generation, with de-clicked chunk edges, waveform scrubbing, and play/pause control for the live stream.
  • Supports optional Whisper auto-transcription for reference transcripts.
  • Includes a Whisper model selector with direct whisper.cpp model downloads.
  • Includes a Speaker Gallery for reusable speaker identities with reference audio, transcript, notes, display image, normalization, and selected-speaker ZIP import/export.
  • Reuses saved speaker reference caches (.hspkcache) after first inference to skip repeated reference-code preparation.
  • Includes per-line speaker assignment, draggable line ordering, speaker-line pauses, line-by-line generation progress, and preflight validation for missing speaker references.
  • Shows live generated-token progress beside elapsed time whenever the native engine reports token totals.
  • Includes a visible generation queue manager for queued UI jobs, with active-job status, edit, delete, and clear controls.
  • Includes a local API with normal WAV/MP3 responses, NDJSON streaming responses, saved-speaker discovery, a detachable Command Centre log window, and a bundled browser test console.
  • Exposes generation controls such as temperature, top-k, top-p, seed mode, max tokens, chunking, emotion, style, speed, pitch, and expressiveness.
  • Exports generated audio as WAV or MP3.
  • Tracks recent generations per mode.
  • Shows NVIDIA hardware telemetry for VRAM, GPU load, power, RAM, and history.
  • Uses default-browser links for GitHub, releases, Whisper model selection, and external downloads.

Supported Systems

Windows, GPU, and tooling targets

Primary target:

  • Windows 11 x64
  • Tauri 2 / WebView2 desktop runtime
  • Visual Studio 2022 MSVC toolchain for source builds
  • NVIDIA RTX GPU with CUDA 13 support for the prebuilt CUDA engine
  • Current NVIDIA driver compatible with CUDA 13
  • Recommended: RTX 30-series, 40-series, or 50-series GPU with enough VRAM for the selected quantization

Likely compatible:

  • Windows 10 x64 with current WebView2 and NVIDIA drivers
  • Other CUDA-capable NVIDIA GPUs if the DLL was built for their CUDA architecture

Not the focus of this desktop package:

  • CPU-only generation
  • macOS desktop packaging

Linux desktop packaging lives on the separate linux branch.

Architecture

Runtime architecture and source boundaries 
Tauri Web UI
  -> Rust command layer
    -> libloading + Windows DLL search path setup
      -> audiocpp_engine.dll C API
        -> ported Higgs Audio v3 C++ runtime
          -> ggml / CUDA backend
            -> Higgs Audio v3 TTS, voice clone, continuation

Important boundary:

  • UI code lives in desktop/src.
  • Reference microphone state, device selection, live metering, and recorder controls live in desktop/src/referenceRecorder.ts instead of the application bootstrap.
  • Rust command glue lives in desktop/src-tauri/src.
  • Native C ABI lives in app/desktop_api/audiocpp_api.h.
  • Native DLL implementation lives in app/desktop_api/audiocpp_api.cpp.
  • Higgs model code lives under src/models/higgs_tts.

Long-running inference runs on Rust blocking worker threads so the WebView stays responsive while the native engine is generating audio.

Runtime Files

Runtime file locations

The three Windows packages run the same application, but they use two different storage modes:

Package Program files Engine downloads Model downloads Settings, speakers, and temporary audio
Portable folder Beside the EXE resources/engine/ beside the EXE models/ beside the EXE data/ beside the EXE
NSIS setup EXE Installed by the NSIS wizard %LOCALAPPDATA%\Higgs Audio v3 Studio\engine\ %USERPROFILE%\audiocpp\models\ Windows per-user app-data/temp folders
MSI installer Installed through Windows Installer %LOCALAPPDATA%\Higgs Audio v3 Studio\engine\ %USERPROFILE%\audiocpp\models\ Windows per-user app-data/temp folders

The portable release is self-contained for all Studio-managed writable data. Keep the complete folder together and launch the EXE from a writable location. The portable.flag marker switches engine/model downloads, settings, saved speakers, reference caches, recordings, temporary audio, and WebView data into the portable directory:

Higgs Audio v3 Studio 0.3.0 Portable/
  Higgs Audio v3 Studio.exe
  portable.flag
  resources/
    engine/                       # empty until Download Engine DLLs is used
    higgs-assets/                 # bundled Higgs config/tokenizer assets
    api-console/                  # bundled browser API test console
  models/
    higgs-q8_0/                   # downloaded GGUF plus model assets
    whisper/                      # optional Whisper downloads
  data/
    speakers/                     # identities, images, audio, transcripts, caches
    temp/                         # prepared/recorded reference audio
    webview/                      # settings, API key, and WebView2 profile

The portable package includes Higgs support assets and the API test console, but does not bundle the native engine/runtime DLLs or multi-gigabyte GGUF weights. Download Engine DLLs fetches the engine package from Hugging Face into resources/engine/. Model and Whisper downloads are stored under models/. Moving the complete portable directory to another writable drive keeps its data with it.

NSIS and MSI are installed builds. Their signed application files and bundled read-only resources live in the Windows installation directory, while mutable downloads and user data are deliberately stored in writable per-user folders. This avoids Access is denied errors under Program Files. NSIS is the normal guided setup EXE; MSI uses Windows Installer and is useful for managed deployment, repair, or MSI-based uninstall tooling. Their runtime behavior is otherwise the same.

For development, place the engine DLL in desktop/src-tauri/resources/engine/. Engine discovery also checks bundled resources and compatible system-installed CUDA/MSVC runtime folders.

Speaker Gallery

Reusable speaker identity storage and ZIP import/export

Speaker Gallery identities are optional. Voice Clone, Continue Speech, and Multi Speaker can use a saved identity, but users can still upload one-off reference audio without saving it. One-off voice-clone references and Speaker Gallery uploads are automatically prepared as WAV and capped to the first 30 seconds so long accidental uploads do not waste inference setup time. Continue Speech keeps the full source audio because that workflow may intentionally continue longer material.

The same reference slots can record from a microphone without leaving the app. Choose an input device, press record, and watch the live level waveform. Stopping the recording prepares a mono WAV and replaces that slot only after the file has been finalized successfully. Recording is available in Voice Clone, Continue Speech, Speaker Gallery, and every Multi Speaker voice card. Whisper transcription remains optional; the recorder does not perform speaker diarization.

When a speaker identity is created or edited, the app keeps its files in the user app data speaker store. Each speaker gets a folder named from the speaker name and internal ID, with:

speakers/
  Speaker_Name_persona_id/
    manifest.json
    reference.wav/mp3/flac
    display.png/jpg/webp
    transcript.txt
    notes.txt
    cache/
      speaker.hspkcache

Export opens a picker so you can choose exactly which speaker identities to include. The portable .zip contains manifest.json plus one speakers/<speaker-name>_<id>/ folder per selected identity. Import reads that ZIP, unpacks the audio/image assets back into the app speaker store, and restores the speaker identity list.

Speaker export/import includes identity metadata, reference audio, transcript, notes, display images, and the saved .hspkcache reference-code cache when it exists. The cache is created after the first saved-speaker inference and is used again by Voice Clone, Continue Speech, Multi Speaker, and saved-speaker API jobs. The file stores discrete codec IDs rather than model KV tensors. The official Q4_K_M, Q5_K, Q6_K, Q8_0, and BF16 builds made from the same source model with the default higgs_tts quantization policy can therefore share one speaker cache because that policy preserves the codec encoder tensors. Regenerate the cache for a different model/codec revision, fine-tune, or custom --policy all quant. Model-internal KV-prefix/activation caches are intentionally not serialized because those are model and quant specific.

Local API

HTTP API, streaming, and Command Centre

The app can run a local API server from the API tab. The default base URL is:

http://127.0.0.1:7077/v1

Every /v1 route requires:

Authorization: Bearer <your-api-key>

Useful routes:

Route Purpose
GET /health No-auth health check.
GET /v1/status Engine, model, queue, and streaming support state.
GET /v1/models Local Higgs model folders detected by the app.
GET /v1/higgs/speakers Saved speaker identities, including speaker:<id> voice names and cache status.
POST /v1/audio/speech OpenAI-style plain TTS or saved-speaker voice clone, returned as WAV or MP3.
POST /v1/higgs/voice-clone Voice clone from a local reference audio path.
POST /v1/higgs/continue-speech Continue an existing local audio file.
POST /v1/higgs/audio/stream Streaming TTS/clone/continue response as newline-delimited JSON events.
POST /v1/higgs/cancel Cancel the active generation.

Finished-file routes accept response_format: "wav" or response_format: "mp3" and return audio/wav or audio/mpeg directly.

/v1/higgs/audio/stream emits NDJSON events such as queued, start, progress, audio, final, done, and error. Audio chunks are delivered as wavBase64 fields so simple clients can parse progress and audio from one response stream. The live chunks are WAV. The final event respects response_format: it returns wavBase64 for WAV or mp3Base64 for MP3.

For script playback, read the HTTP response line-by-line. When event is audio, base64-decode wavBase64 and feed those WAV bytes to your player or audio queue. When event is final, check encoding. Save wavBase64 when it is wav-base64, or mp3Base64 when it is mp3-base64.

Minimal Python stream reader:

import base64
import json
import requests

with requests.post(url, headers=headers, json=payload, stream=True, timeout=600) as r:
    r.raise_for_status()
    for line in r.iter_lines(decode_unicode=True):
        if not line:
            continue
        event = json.loads(line)
        if event["event"] == "audio":
            wav_chunk = base64.b64decode(event["wavBase64"])
            # Push wav_chunk to your audio playback queue here.
        elif event["event"] == "final":
            if event.get("encoding") == "mp3-base64":
                open("final.mp3", "wb").write(base64.b64decode(event["mp3Base64"]))
            else:
                open("final.wav", "wb").write(base64.b64decode(event["wavBase64"]))

The API tab includes examples for curl, Python, JavaScript, and PowerShell. The Test Console button opens a bundled, self-contained test harness in the system browser with the current API base URL; the app also copies the current API key to the clipboard for pasting into the console. The console can run health/status checks and exercise plain TTS, reference or saved-speaker cloning, continuation, WAV/MP3 finished responses, and NDJSON streaming. Its Command Centre can be popped out into a separate window with filters for info, warnings, errors, requests, and jobs. If the main studio window is minimized to the system tray, the popped-out Command Centre remains visible. Speaker Gallery changes are hot-synced into the running API, so saved speaker IDs do not require an API restart after create/edit/delete.

Install For Users

Portable release

  1. Download the portable release package from GitHub Releases.

  2. Put it in a normal writable folder, for example:

    C:\AI\Higgs-Audio-v3-Studio\

  3. Keep the resources/ folder beside Higgs Audio v3 Studio.exe.

  4. Keep portable.flag beside the executable. This marker prevents the portable app from writing its runtime data into the Windows user profile.

  5. Run Higgs Audio v3 Studio.exe.

  6. The portable app creates and uses only these local writable folders:

    Higgs Audio v3 Studio 0.3.0 Portable/
  Higgs Audio v3 Studio.exe
  portable.flag
  resources/engine/       # populated by Download Engine DLLs
  models/                 # Higgs and Whisper downloads
  data/speakers/          # saved speaker identities and caches
  data/temp/              # prepared and recorded reference audio
  data/webview/           # settings, API key, and WebView2 state

  7. If the engine package is missing, click Download Engine DLLs.

  8. Use the Model panel to download or browse to a Higgs model.

  9. Load the engine and model.

NSIS and MSI installers
  1. Download the NSIS *_x64-setup.exe for a normal guided installation, or the *_x64_en-US.msi for Windows Installer/managed deployment.
  2. Install normally. Both packages install the same app and bundled resources.
  3. Launch the app from the Start Menu.
  4. Download or browse to the engine/model files from inside the app. Downloads, settings, speakers, and temporary files use writable per-user locations, not the protected application installation folder.

Model Setup

Higgs and Whisper model setup

The model selector expects model folders, not loose files. A good downloaded folder layout is:

models/
  higgs-q8_0/
    q8_0.gguf
    chat_template.jinja
    config.json
    higgs_audio_v2_tokenizer_config.json
    tokenizer.json
    tokenizer_config.json
  higgs-q6_k/
    q6_k.gguf
  higgs-q5_k/
    q5_k.gguf
  higgs-q4_k_m/
    q4_k_m.gguf
  higgs-bf16/
    bf16.gguf

Higgs Audio v3 Q8_0 is the recommended model in the app. In-app Higgs model downloads now fetch the whole selected model folder: the .gguf file plus chat_template.jinja, config.json, higgs_audio_v2_tokenizer_config.json, tokenizer.json, and tokenizer_config.json. The progress bar shows the current file and per-file download progress, for example File 1/6: q8_0.gguf.

Recommended VRAM:

Model VRAM
Higgs Q4_K_M 8 GB
Higgs Q5_K 9 GB
Higgs Q6_K 10 GB
Higgs Q8_0 12 GB
Higgs BF16 16 GB

Use Browse... if a model is somewhere else. In-app model downloads use a user-writable folder by default:

C:\Users\<you>\audiocpp\models\

For Whisper auto-transcription, use the Whisper panel on the left:

  1. Select a Whisper preset.
  2. The recommended default is base.en-q8_0.
  3. The smaller turbo option large-v3-turbo-q5_0 is also highlighted.
  4. Click Download, or click Browse... and select an existing ggml-*.bin.

Build Requirements

Toolchain requirements

Known-good Windows build inputs:

Dependency Version / Notes
Visual Studio Build Tools 2022 or newer, MSVC C++ workload
Windows SDK Installed with Visual Studio Build Tools
CMake 3.20+
Ninja 1.11+
CUDA Toolkit CUDA 13.x for the prebuilt-compatible CUDA engine
Rust Stable MSVC toolchain
Node.js 20+ recommended
WebView2 Required by Tauri on Windows

Build Native Engine

Build the C++ CUDA DLL

From the repository root:

# Build the desktop DLL for a CUDA release preset.
.\scripts\build_windows.ps1 `
  -Preset windows-cuda-release `
  -Target audiocpp_engine `
  -Jobs 16

To force CUDA architectures:

.\scripts\build_windows.ps1 `
  -Preset windows-cuda-release `
  -Target audiocpp_engine `
  -CudaArchitectures "86;89;120" `
  -Jobs 16

Common architecture targets:

GPU family CUDA architecture
RTX 30-series 86
RTX 40-series 89
RTX 50-series 120 or 120a-real, depending on CUDA/toolchain support

The DLL is written to:

build/windows-cuda-release/bin/audiocpp_engine.dll

For development, copy it to:

desktop/src-tauri/resources/engine/audiocpp_engine.dll

The native DLL is for development and the Hugging Face engines/ package. It is intentionally not embedded in NSIS, MSI, or portable application releases.

To produce MSI, NSIS, and a self-contained portable folder in one pass, use:

.\scripts\package_windows_release.ps1

The script adds portable.flag only to the portable folder. It optionally runs UPX on the copied portable executable when upx.exe is available; installer builds continue to use Tauri's normal MSI/NSIS compression and storage paths. Engine DLLs are intentionally excluded from every application package and are downloaded from the Hugging Face engines/ folder on demand.

Build Desktop App

Build or run the Tauri app

From the repository root:

cd desktop
npm install
npm run build:vite
cd src-tauri
cargo check
cd ..
npm run build

Fast local app run:

cd desktop
npx tauri dev

Build only the frontend:

cd desktop
npm run build:vite

Build the Tauri app without generating installer bundles:

cd desktop
npx tauri build --no-bundle

Full Tauri build output is under:

desktop/src-tauri/target/release/
desktop/src-tauri/target/release/bundle/

Verification

Local verification checks

Useful checks:

# Frontend TypeScript + Vite production build
cd desktop
npm run build:vite

# Rust command layer
cd src-tauri
cargo check
cd ..\..

# Native DLL target
.\scripts\build_windows.ps1 -Preset windows-cuda-release -Target audiocpp_engine

Expected behavior:

  • The app opens to the main TTS workflow.
  • Download Engine DLLs downloads audiocpp_engine.dll plus the required CUDA/MSVC runtime DLLs.
  • Higgs model downloads show File n/6 and download the selected model folder assets plus GGUF weights.
  • Load Engine changes the engine chip from unloaded to loaded.
  • Load Model enables generation after a valid model folder is selected.
  • Voice clone and multi-speaker workflows require reference audio. New uploaded clone/Speaker Gallery references are auto-cropped to 30 seconds.
  • Microphone input selection, live recording waveform, stop, replace, and remove controls work in Voice Clone, Continue Speech, Speaker Gallery, and Multi Speaker voice cards.
  • Reference trim controls preview a selected range, enforce the 30-second cloning limit, write a new WAV, and refresh the reference/cache state used by generation.
  • Multi-speaker generation checks all speech lines before starting. If a line points to a missing speaker or a speaker without a reference voice, the app stops immediately and tells you which line to fix.
  • Whisper auto-transcription requires a selected ggml-*.bin Whisper model.
  • OGG/Opus and WebM/Opus references should load directly. Corrupt, empty, unsupported multi-stream, or unsupported multichannel Opus files return a specific decode error instead of an empty waveform.
  • Generation progress shows Tokens current / maximum beside elapsed time when token telemetry is available.
  • Test Console opens the bundled API harness in the default browser and pre-fills the current API root URL.

Troubleshooting

Common issues and fixes

Port 1420 is already in use

Another Vite dev server is already running.

Check the port:

Get-NetTCPConnection -LocalPort 1420 -ErrorAction SilentlyContinue |
  Select-Object LocalAddress,LocalPort,State,OwningProcess

Stop the old process or run the app after that server exits.

Engine library not found

The app could not find audiocpp_engine.dll.

Fix one of these:

  • Click Download Engine DLLs.
  • Copy the DLL beside the release executable.
  • In dev, copy it to desktop/src-tauri/resources/engine/audiocpp_engine.dll.

Load Model is disabled

Load the engine first, then select a valid model folder.

The app lists folders containing model weights such as model.gguf or model.safetensors. Loose files in the root models/ folder will not appear as full model entries.

CUDA DLL load errors

Version 0.2.31 added an engine dependency preflight. If Windows cannot load audiocpp_engine.dll, the app checks common loader dependencies first and shows a repair dialog listing missing DLLs such as nvcuda.dll, cublas64_13.dll, cublasLt64_13.dll, vcruntime140.dll, vcruntime140_1.dll, msvcp140.dll, or VCOMP140.DLL.

Make sure:

  • NVIDIA driver is current.
  • Click Download Engine DLLs, or make sure CUDA Toolkit 13.x runtime DLLs required by the engine are on PATH.
  • Click Download Engine DLLs, or install Microsoft Visual C++ Redistributable 2015-2022 x64.
  • The engine DLL was built for your GPU architecture.

VRAM spikes during generation

Short VRAM spikes can happen during inference. They usually come from temporary workspace buffers, KV cache allocation, CUDA/ggml scratch allocations, audio codec stages, or graph execution setup. A quantized model can still need extra transient memory while generating.

Seeing the card jump close to full VRAM for a moment does not always mean the model weights themselves need that much memory. CUDA/ggml can reserve large workspace and scratch regions sized for the current graph/session, and Windows or NVML may report that reserved memory as used. The Higgs generator decode graph allocates KV cache for the requested maximum token cap, so very high max_tokens values can reserve much more VRAM up front even when the text is short.

Version 0.2.31 and later releases Higgs runtime graphs and codec graphs after each request, releases them when streaming is cancelled or errors out, checks cancel inside the native decode loop, and sends per-stage native VRAM diagnostics to the Command Centre. Use those vram stage=... log lines to see whether a spike comes from reference encoding, generator decode graph allocation, streaming codec decode, final codec decode, or cleanup. The packaged CUDA engine now uses F16 decode KV cache by default to reduce cache VRAM pressure, with an F32 diagnostic fallback available for troubleshooting.

If you run out of memory:

  • Use a smaller or lower-quantized model.
  • Close other GPU-heavy apps.
  • Reduce max tokens; the UI default is 1024.
  • Disable longform chunking or use smaller chunks.
  • Try a smaller reference clip.

Whisper auto-transcribe does nothing

Select a Whisper model in the left Whisper panel. The recommended default is base.en-q8_0. The model file should be a ggml-*.bin from whisper.cpp.

Downloads do not start

Check that the URL is a direct Hugging Face resolve/main/... URL, not a browser blob/main/... page.

Good:

https://huggingface.co/user/repo/resolve/main/path/file.bin

Not good for direct app download:

https://huggingface.co/user/repo/blob/main/path/file.bin

App links open inside the app instead of browser

Links should be routed through the Rust open_external_url command. If a new link is added, wire it through that command instead of using an in-app WebView navigation.

Responsible Use

Do not use Higgs Audio v3 Studio, Higgs TTS 3, or any voice-cloning workflow to impersonate people without consent, create malicious or deceptive voices, defraud others, evade identification, harass people, or cause harm. Generated voices should be used only where you have the rights and consent needed for the source voice, transcript, and intended output.

Project Layout

app/desktop_api/               Native C ABI used by the Tauri app
desktop/                       Tauri 2 + Vite frontend
desktop/src/                   TypeScript UI
desktop/src-tauri/src/         Rust command layer and DLL loader
include/                       Public C++ framework headers
src/models/higgs_tts/          Higgs Audio v3 model implementation
external/ggml/                 Vendored ggml backend sources
external/whisper.cpp/          Whisper submodule used by the engine DLL
scripts/build_windows.ps1      Windows CMake/MSVC build helper

Upstream And Credits

This desktop app builds on:

  • The ported Higgs Audio v3 C++/CUDA engine implemented for this Studio app.
  • ggml, used by the native backend.
  • whisper.cpp, used for optional local transcription.
  • libopus through the Rust audiopus bindings, statically linked for native OGG/WebM Opus reference decoding.
  • Higgs Audio v3 model work from Boson AI.
  • Tauri 2, Rust, Vite, and TypeScript for the desktop shell.

Check upstream model licenses before redistributing model weights or using them commercially.

Citation

@misc{bosonai_higgs_audio_tts_v3_2026,
  title  = {Higgs TTS 3: Conversational Speech for Voice AI from Boson AI},
  author = {Boson AI},
  year   = {2026},
  howpublished = {https://huggingface.co/bosonai/higgs-tts-3-4b},
}

License

Application source code in this repository is Apache 2.0; see LICENSE. Higgs TTS 3 model weights and upstream model assets are governed by the Boson Higgs TTS 3 Research and Non-Commercial License; see the upstream model license.

About

Windows / Linux desktop app built with Rust/Tauri for local Higgs Audio v3 TTS inference + local dev api through a native C++/CUDA port

Topics

cppcudaggufhiggs-audiolinuxlinux-appportrusttauri-apptext-to-speechttsvitevoice-clonevoice-cloningwindows

Resources

Readme
License
Activity

Stars

33 stars

Watchers

3 watching

Forks

6 forks
Report repository

Releases

Contributors

Languages