TTS-Workbench

TTS-Workbench

Docker app from heroeswearkapes Community Apps' Repository

TTS Workbench is a self-hosted multi-engine AI text-to-speech platform with a unified Gradio interface.

Requirements


CPU-only operation is supported.

For Intel GPU acceleration:
- An Intel Arc GPU must be available on the Unraid host.
- The Intel GPU render device must be passed through.
- Change the Intel GPU device entry to match your system.

The exact /dev/dri/renderD### device varies between systems.
Overview

TTS Workbench is a self-hosted multi-engine AI text-to-speech platform with a unified Gradio interface.

Supports:

  • Kokoro preset voice synthesis
  • F5-TTS voice cloning
  • Qwen3-TTS generation

Includes dynamic engine controls, runtime diagnostics, model management, and Intel XPU acceleration support for compatible Intel Arc GPUs.

Timezone and updates:
New output folders for Kokoro, F5-TTS, and Qwen3-TTS follow the container's local date. Unraid's Docker manager normally supplies the host timezone automatically. To use a different timezone, add a TZ environment variable such as America/Los_Angeles or Etc/UTC.

Update the container to receive the timezone fix. Standard timezone names work without a host /etc/localtime mount. Existing output files and folders are retained.

TTS Workbench

TTS Workbench is a self-hosted, multi-engine text-to-speech platform with one local Gradio interface for narration, voice cloning, and emerging TTS models. It exists to make engines with very different controls and runtime requirements usable through a consistent workflow without sending text, reference recordings, or generated audio to a hosted application.

The current application supports fast preset-voice narration with Kokoro, reference-audio voice cloning with F5-TTS, and an integrated Qwen3-TTS CustomVoice runtime. Models load only when first used and generated audio and metadata remain in local storage.

Quick start · Engines · Hardware · Timezone · Storage · Architecture · Troubleshooting

Feature overview

  • One self-hosted UI: choose an engine and model, then use the controls that adapter declares.
  • Multiple synthesis workflows: preset voices, reference-audio cloning, optional transcription, language selection, and model-specific settings.
  • Local artifacts: model caches, voice assets, source material, generated WAV files, and metadata stay in mounted storage.
  • CPU and validated Intel XPU paths: CPU fallback works without a GPU; F5-TTS synthesis and Qwen model loading have been exercised on Intel Arc Pro B70 hardware.
  • Runtime visibility: a collapsible status panel reports model load state, device, precision, cleanup progress, timing, real-time factor, warnings, and errors.
  • Extensible by design: adapters and schemas add engines without embedding engine-specific behavior in the Gradio frontend.

Quick start

You need Docker Engine with the Compose plugin, an x86-64 CPU, enough disk space for the selected models, and network access for first-use model downloads. A GPU is optional. The default Compose configuration is CPU-compatible and does not require /dev/dri.

git clone https://github.com/heroeswearkapes/tts-workbench.git
cd tts-workbench
test -f .env || cp .env.example .env

For this first-time setup, edit .env before starting the container. Set TTS_DATA_ROOT to the parent directory for your models, voices, input, and output, and set CONFIG_PATH to your configuration directory. Set TZ to your preferred timezone if you want local-date output folders; Compose defaults to Etc/UTC. For example:

TZ=America/New_York

Pull the published image and start the service:

docker compose pull
docker compose up -d

Open http://localhost:7860 (or the port selected with TTS_PORT), select an engine and model, enter text, and generate audio. The first request for an engine may take longer while its model and voice assets download and the runtime loads.

The standard Compose configuration mounts the host paths selected in .env:

Host path Container path Contains
${TTS_DATA_ROOT}/models /models Model weights and framework caches
${TTS_DATA_ROOT}/voices /voices Preset voice assets
${TTS_DATA_ROOT}/input /input Persistent reference material
${TTS_DATA_ROOT}/output /output Generated audio and metadata
${CONFIG_PATH} /config Persistent application configuration

Use docker compose logs -f to follow logs and docker compose down to stop and remove the service container. Data in the configured host directories is retained. Intel XPU users can use the same published image with the device-passthrough command.

Engine support

Engine Maturity Active runtime Devices
Kokoro Fully supported Kokoro 82M CPU (FP32)
F5-TTS Fully supported F5-TTS v1 Base CPU or Intel XPU (FP32)
Qwen3-TTS Integrated Qwen3-TTS 12Hz 0.6B CustomVoice CPU (FP32) or Intel XPU (BF16/FP32)

“Fully supported” means the listed workflow has an end-to-end runtime and test coverage. “Integrated” means the listed active model has a runtime in the main application, while additional models may be descriptors only. Descriptor-only Qwen models are visible foundations for future work and cannot generate audio.

Kokoro

Kokoro is the fast narration engine. It provides:

  • a catalog of 54 preset voices;
  • voice selection and speech-speed control;
  • voice descriptors with stable IDs, display names, language, gender, category, and accent where known;
  • American and British English, Japanese, Mandarin Chinese, Spanish, French, Hindi, Italian, and Brazilian Portuguese voice groups;
  • serialized CPU inference using FP32; and
  • lazy download of the selected voice asset.

Kokoro model files are stored under models/kokoro/kokoro-82m/, while voice assets are stored independently under voices/kokoro/.

F5-TTS

F5-TTS is the reference-audio voice-cloning engine. It supports:

  • a required reference recording;
  • an optional exact reference transcript;
  • automatic reference transcription when the transcript is omitted;
  • speech-speed control;
  • CPU synthesis; and
  • Intel XPU synthesis.

Reference uploads include:

  • WAV
  • M4A
  • MP3
  • WebM
  • Ogg

FFmpeg performs the initial decode and converts the source into mono, 24 kHz, 16-bit PCM WAV. SoundFile is the final decoder into the numeric data passed to F5. FFmpeg-supported formats such as FLAC also work, although the formats above cover the normal upload and browser-recording paths.

If reference text is supplied, it is passed directly to F5 and Whisper is not loaded. If it is blank, the explicit WhisperProcessor and WhisperForConditionalGeneration path transcribes normalized 16 kHz audio on CPU. F5 synthesis remains on its selected CPU or XPU device while transcription stays on CPU.

Qwen3-TTS

Qwen3-TTS is integrated into the main adapter registry. The active inference runtime is:

Qwen/Qwen3-TTS-12Hz-0.6B-CustomVoice

It supports nine preset speakers, language selection, sampling controls, lazy checkpoint download, CPU fallback, Intel XPU selection, and runtime status reporting.

The adapter also exposes schemas and model descriptors for:

  • Qwen/Qwen3-TTS-12Hz-0.6B-Base
  • Qwen/Qwen3-TTS-12Hz-1.7B-CustomVoice
  • Qwen/Qwen3-TTS-12Hz-1.7B-Base
  • Qwen/Qwen3-TTS-12Hz-1.7B-VoiceDesign

Those four descriptors let the generic UI represent voice cloning, larger CustomVoice, and VoiceDesign inputs, but their inference paths are not yet integrated. Only the 0.6B CustomVoice model should be treated as active.

The UI records and forwards a style instruction for the active model. The published 0.6B CustomVoice implementation currently clears instruct internally, so the instruction does not provide reliable acoustic style control. Output metadata explicitly records that limitation. The field remains available for schema compatibility and future model support.

Qwen imports are lazy. Missing Qwen packages do not prevent the application, Kokoro, or F5-TTS from starting.

Example workflow

  1. Select Kokoro for fast preset narration, F5-TTS to clone a reference recording, or the active Qwen3-TTS model for a multilingual preset voice.
  2. The UI displays only the fields declared by that engine/model schema.
  3. Enter synthesis text and provide the selected workflow's voice or reference inputs.
  4. Generate. The adapter validates the request, lazily loads or reuses its runtime session, and writes a normalized WAV plus JSON metadata.
  5. Play or download the audio and expand Runtime status to inspect the device, precision, load state, timing, real-time factor, or any error.

Hardware support

Backend/hardware Current support Validation boundary
x86-64 CPU Supported Kokoro, F5-TTS, and active Qwen runtime paths; performance depends on the host
Intel Arc Pro B70 Validated where noted F5-TTS XPU synthesis; Qwen 0.6B CustomVoice import/model load
Other Intel XPU devices Not hardware-validated May work with compatible drivers and runtimes, but no compatibility claim is made
NVIDIA CUDA Architecture only No CUDA runtime or CUDA Docker image is currently provided

CPU

CPU is always available as the fallback backend. Kokoro is CPU-only. F5-TTS and the active Qwen runtime also support CPU, although their larger models may be slower than interactive workloads require.

Intel XPU

The development image uses torch==2.11.0+xpu and matching Torchaudio wheels. F5-TTS and Qwen select XPU automatically when torch.xpu.is_available() is true; otherwise they fall back to CPU. Kokoro remains on CPU.

Atlas validation with an Intel Arc Pro B70 confirmed:

  • Intel device passthrough into the Ubuntu container;
  • PyTorch XPU detection with the Intel OpenCL and Level Zero runtimes;
  • F5-TTS model loading and synthesis on XPU; and
  • Qwen3-TTS 0.6B CustomVoice package import and model loading on XPU.

The CPU-only dockerbuilder cannot validate XPU hardware, so XPU generation checks remain an Atlas responsibility.

CUDA architecture

The domain contracts and generic runtime-status model can represent a cuda backend without UI changes. The current adapters and development image do not ship a CUDA runtime: Kokoro accepts CPU, and F5/Qwen currently accept CPU or XPU. CUDA engine enablement requires a compatible PyTorch image and explicit adapter runtime validation; it is an architectural extension point, not a currently validated execution mode.

Installation

Docker Compose

Docker is the recommended way to run all current engine dependencies together. The image uses Ubuntu 26.04 with Python 3.11 copied from the official Python runtime stage. It includes Gradio, Kokoro, F5-TTS, Qwen3-TTS, FFmpeg, libsndfile, SoX, eSpeak NG, the PyTorch XPU build, the Intel GPU userspace runtime, and tzdata for named timezone support.

After configuring .env as described in Quick start, start the CPU-compatible service with the published image:

docker compose pull
docker compose up -d

The standard Compose file uses ${IMAGE_NAME}:${IMAGE_TAG} from .env, persists all five storage paths, and exposes port 7860 through the configured host port. It runs the source packaged in the image. The same image starts normally without /dev/dri and falls back to CPU.

For a local image build, run docker build -t tts-workbench:dev . from the repository root. The separate docker-compose.dev.yml is intended for source development and mounts ./src read-only into the container. Its storage variables differ from the standard Compose file, so review its volume mappings before using it with an existing .env.

Stop it with:

docker compose down

Unraid

The Unraid template is maintained in unraid-community-apps and uses heroeswearkapes/tts-workbench:latest. Configure the WebUI port, persistent storage paths, and optional Intel GPU device for your server.

Unraid's Docker manager normally supplies the server's timezone to the container automatically. A custom TZ variable is only needed to override that timezone. See Timezone and output folders for configuration and upgrade guidance.

Intel XPU Docker run

The host needs a working Intel graphics driver and a usable /dev/dri render device. This standalone example stores data in directories under the current working directory. For an existing installation, substitute your established host storage paths in the volume arguments; docker run does not read the Compose .env file. Pass DRI into the container:

docker run --rm \
  --name tts-workbench \
  --env TZ=Etc/UTC \
  --device=/dev/dri:/dev/dri \
  --publish 7860:7860 \
  --volume "$PWD/models:/models" \
  --volume "$PWD/voices:/voices" \
  --volume "$PWD/input:/input" \
  --volume "$PWD/output:/output" \
  --volume "$PWD/config:/config" \
  heroeswearkapes/tts-workbench:latest

Replace Etc/UTC with your preferred IANA timezone, such as America/New_York or America/Los_Angeles, to use local-date output folders.

To pass only the render node used during Atlas validation, replace the device argument with:

--device=/dev/dri/renderD131:/dev/dri/renderD131

Device discovery can be checked without starting Gradio:

docker run --rm \
  --device=/dev/dri:/dev/dri \
  heroeswearkapes/tts-workbench:latest \
  tts-workbench-devices --device xpu --xpu-index 0 --json

Local CPU development

Use Python 3.11. Native audio packages are required for the full runtime; on a Debian or Ubuntu development host:

sudo apt-get update
sudo apt-get install ffmpeg libsndfile1 sox espeak-ng
python3.11 -m venv .venv
. .venv/bin/activate
python -m pip install --upgrade pip setuptools wheel
python -m pip install --editable .

Install only the engines needed in that environment:

python -m pip install --editable '.[kokoro]'
python -m pip install --editable '.[f5]'
python -m pip install --editable '.[qwen]'

Or install all engine extras together:

python -m pip install --editable '.[kokoro,f5,qwen]'

Install the backend-appropriate matching Torch and Torchaudio wheels before the engine extras. Qwen requires qwen-tts==0.1.1, transformers==4.57.3, and accelerate==1.12.0; the Docker image pins that validated combination with Torch/Torchaudio 2.11.0+xpu. Flash Attention is intentionally not installed.

Launch the application from the repository root:

tts-workbench-devices
tts-workbench

The base install contains Gradio and the engine descriptors. Optional engine dependencies are imported only when their runtime is requested.

Docker runtime details

Item Current value
Base OS Ubuntu 26.04
Python 3.11
HTTP port 7860
Torch 2.11.0 XPU build by default
Intel userspace packages intel-opencl-icd, libze1, libze-intel-gpu1
Timezone database tzdata; named timezones are selected through TZ
Persistent paths /models, /voices, /input, /output, /config
Healthcheck HTTP request to 127.0.0.1:7860

The application is configured with TTS_WORKBENCH_ROOT=/ in the image. Model and framework caches also live below /models, so recreating a container does not require downloading every artifact again.

The entrypoint checks that all storage paths are writable, prints CPU/XPU diagnostics, and then starts Gradio. Models are downloaded lazily rather than baked into the image.

Timezone and output folders

Kokoro, F5-TTS, and Qwen3-TTS organize new audio and metadata under:

/output/YYYY-MM-DD/<job-id>/

YYYY-MM-DD is the container's local date when the completed job is saved. For example, at 2026-11-13 16:30 in America/Los_Angeles, UTC has already reached November 14. The local-date output folder is still 2026-11-13.

The image includes tzdata, so IANA timezone names such as America/Los_Angeles and America/New_York handle daylight saving time automatically according to the installed timezone database. Use Etc/UTC to keep UTC dates. This changes date selection for new jobs; existing output folders and files are not renamed, moved, or deleted.

Choose a timezone

Deployment Default behavior Set a different timezone
Unraid Docker manager Uses the Unraid server's timezone unless overridden Add or edit a container Variable with Key TZ and an IANA timezone as its Value
Supplied Docker Compose files Uses TZ from the shell or .env, with Etc/UTC as the fallback when unset or empty Set TZ=America/Los_Angeles in .env and recreate the service
Direct docker run Uses the image's local timezone, normally UTC without an override Add --env TZ=America/Los_Angeles when creating the container

TZ sets the container's local timezone generally, including output date folders. It is not a separate output-only setting. The standard Unraid template leaves the host timezone inheritance intact instead of forcing a fixed timezone. Environment variables can be managed in Unraid's container configuration screen; see the Unraid container documentation.

For Compose, edit the existing .env file rather than replacing it during an upgrade. A TZ exported in the shell takes precedence over the value in .env; check that value if the container uses an unexpected timezone.

Updating an existing installation

The timezone fix requires the updated image. On Unraid, update TTS Workbench from the Docker tab so the container is recreated with the new image.

For a Compose installation created before the timezone fix, also update the Compose configuration while preserving your local settings. Alternatively, add this entry under the TTS Workbench service's existing environment mapping so the TZ value in .env reaches the container:

TZ: ${TZ:-Etc/UTC}

After the configuration is updated, pull the image and recreate the standard Compose service:

docker compose pull
docker compose up -d

For another Compose configuration using the published image, supply the same -f option you normally use for that installation. For source development, update your source checkout and rebuild the local image with docker compose -f docker-compose.dev.yml up -d --build instead.

Recreating the container applies the selected image and environment while retaining data in the configured host storage paths. Restarting an existing container does not install a new image or apply changes made only to .env.

With the updated image and a valid named TZ, a host /etc/localtime bind mount is not required. If you previously used TZ=/etc/localtime, keep that workaround until you are ready to switch to a named timezone or Unraid's automatic host setting, then verify the result before removing the old mount.

Verify the timezone

The standard Compose container is named tts-workbench. For Unraid or a custom deployment, replace that name below with the actual container name:

docker exec tts-workbench dpkg-query -W tzdata
docker exec tts-workbench printenv TZ
docker exec tts-workbench date
docker exec tts-workbench python -c 'from datetime import datetime; print(datetime.now().astimezone().isoformat())'

Check that tzdata is installed and the operating system and Python agree on the intended local time and UTC offset. Generate a short audio sample and confirm that its new output folder matches the local date. Testing after UTC midnight but before local midnight makes the change easy to verify for timezones west of UTC.

Runtime Status panel

The bottom of the Gradio interface contains one collapsible, engine-independent Runtime Status panel. It consumes immutable RuntimeStatus snapshots and is updated on engine/model selection, before generation, after a runtime session loads, during asynchronous unload/device cleanup, after generation, and after handled failures.

It reports:

  • active engine and model;
  • active loaded runtime, independently from the selected form;
  • lifecycle state (unloaded, loading, generating, ready, unloading, or error);
  • device backend (cpu, xpu, or future cuda);
  • device name when available;
  • precision when available;
  • whether the runtime is loaded;
  • device cleanup state and cache-clear result;
  • last generation duration;
  • generated audio duration;
  • real-time factor; and
  • warnings and errors.

Real-time factor is generation time divided by generated audio duration. A value below 1.0× means generation was faster than real time.

Active engine: F5-TTS (f5)
Active model: F5-TTS v1 Base (f5-tts-v1-base)
State: ready
Device backend: xpu
Device name: Intel Arc Pro B70
Precision: fp32
Runtime loaded: yes
Last generation: 2.000 s
Generated audio: 5.000 s
Real-time factor: 0.400×

Storage layout

With a repository-local development root, runtime storage looks like:

models/
├── .cache/
├── f5/
│   └── f5-tts-v1-base/
├── kokoro/
│   └── kokoro-82m/
└── qwen/
    └── Qwen3-TTS-12Hz-0.6B-CustomVoice/
voices/
└── kokoro/
    ├── af_heart.pt
    └── ...
input/
output/
└── YYYY-MM-DD/
    └── <job-id>/
        ├── audio.wav
        └── metadata.json
config/
Path Purpose
models/ Engine weights and persistent framework caches
voices/ Independently downloaded preset voice assets
input/ Persistent user-managed reference audio and text
output/ Generated WAV files and JSON metadata grouped by local date and job ID
config/ Persistent configuration storage reserved for application settings

In Docker these map directly to /models, /voices, /input, /output, and /config. Gradio is allowed to serve generated files from /output and trusted inputs from /voices and /input; /models is intentionally not exposed.

The dated output folder follows the configured container timezone. See Timezone and output folders for deployment defaults and configuration examples.

Troubleshooting

Output folders use an unexpected date

Confirm that the container uses the updated image, then check its TZ value and local time with the verification commands. Compose defaults to UTC when TZ is unset or empty, while normal Unraid Docker manager installations receive the server's timezone automatically. Check a newly generated job: older output folders retain their original names.

XPU is not detected

First verify that the render device exists and is accessible on the host:

ls -la /dev/dri

Then verify that it was passed into the container and that the XPU-enabled Torch build is installed:

docker run --rm --device=/dev/dri:/dev/dri heroeswearkapes/tts-workbench:latest \
  python -c 'import torch; print(torch.__version__); print(torch.xpu.is_available()); print(torch.xpu.device_count())'

If the device is visible but torch.xpu.is_available() is false, check host driver compatibility, render-node permissions, container device mapping, and the Intel userspace packages described below. CPU fallback is expected when no usable XPU exists.

Intel Level Zero runtime is missing

The development image installs the packages needed by the known-good Atlas environment:

  • intel-opencl-icd
  • libze1
  • libze-intel-gpu1

Verify them inside the image:

docker run --rm --entrypoint dpkg-query heroeswearkapes/tts-workbench:latest \
  --show intel-opencl-icd libze1 libze-intel-gpu1

An image based on a distribution that lacks libze-intel-gpu1 can expose a DRI render node while still failing PyTorch XPU detection. Use the provided Ubuntu image or install a matching Intel Level Zero runtime.

Optional engine dependencies are missing

The application intentionally starts without every model package. An engine dependency error means the selected adapter reached its lazy runtime boundary. Install the corresponding extra:

python -m pip install --editable '.[kokoro]'
python -m pip install --editable '.[f5]'
python -m pip install --editable '.[qwen]'
python -m pip check

For Qwen, also confirm that the exact validated versions are present:

python -c 'import importlib.metadata as m; print(m.version("qwen-tts")); print(m.version("transformers")); print(m.version("accelerate"))'

Expected values are 0.1.1, 4.57.3, and 1.12.0 respectively.

Reference audio fails to decode

Confirm that FFmpeg is installed and can inspect the upload:

ffmpeg -hide_banner -i reference.m4a

To create a known-good F5 reference manually:

ffmpeg -i reference.m4a -vn -ac 1 -ar 24000 -c:a pcm_s16le reference.wav

Use a short, clean recording with audible speech. F5 reads at most the first 12 seconds. Browser recordings may use WebM or Ogg containers even when the file extension is unexpected; FFmpeg performs format detection from the content.

Model download fails

Kokoro, F5-TTS, Qwen3-TTS, and Whisper obtain missing artifacts on first use. Check:

  • internet and DNS access to the model host;
  • available disk space under models/ or /models;
  • write permissions on models/, voices/, and their mounted counterparts;
  • proxy or Hugging Face authentication requirements; and
  • whether an interrupted download left an incomplete local checkpoint.

Container logs and the Runtime Status panel contain the underlying load error:

docker logs tts-workbench

Do not put model storage behind Gradio's allowed paths; model files are runtime assets and should remain private.

Development architecture

flowchart LR
    Browser[Browser] --> UI[Schema-driven Gradio UI]
    UI --> Controller[Generic request controller]
    Controller --> Registry[Engine registry]
    Registry --> Kokoro[Kokoro adapter]
    Registry --> F5[F5-TTS adapter]
    Registry --> Qwen[Qwen3-TTS adapter]
    Kokoro --> Sessions[Lazy runtime sessions]
    F5 --> Sessions
    Qwen --> Sessions
    Sessions --> Storage[(Local models, voices, input, output)]
    Sessions --> Status[RuntimeStatus snapshots]
    Status --> UI
  • Adapter registry: each engine implements the common adapter interface and registers an engine descriptor, model descriptors, capabilities, voices, inputs, settings, generation, and optional runtime-status reporting.
  • Schema-driven UI: Gradio creates persistent generic components from engine schemas. Switching engines or models changes visible forms without adding if engine == ... logic to the frontend.
  • Normalized requests/results: the controller translates component values into SynthesisRequest; every runtime returns SynthesisResult with engine, model, audio path, sample rate, duration, and generation timing.
  • Runtime status: immutable snapshots merge selected descriptors, hardware availability, loaded adapter sessions, timings, warnings, and errors. The UI only formats this shared status contract.
  • Lazy loading and lifecycle management: engine packages import at session creation, and the active session is reused until the selected engine/model changes. Selection itself remains descriptor-only; a generic runtime manager unloads stale sessions, releases references, runs garbage collection, and clears XPU/CUDA allocator caches without blocking the selection callback.
  • Engine isolation: Kokoro, F5-TTS, and Qwen3-TTS runtime code remains separate from the generic Gradio renderer.

Run the test suite from the repository root:

PYTHONPATH=src python -m unittest discover -s tests -v

The standalone Qwen probe and its historical validation notes are documented in experiments/qwen/README.md and docs/qwen-runtime-research.md.

Acknowledgments

Thank you to @Acheron4171 for the detailed timezone bug report in issue #1 and for contributing the fixes in PRs #2, #3, #4, #5, and #6.

Their contributions added timezone data to the Docker image, configurable timezone support to the Compose files, and local-date output folders across Kokoro, F5-TTS, and Qwen3-TTS. Thank you for helping improve TTS Workbench for everyone who uses it!

Categories

Download Statistics

2,997
Total Downloads

Related apps

Explore more like this

Explore all

Links

Details

Repository
heroeswearkapes/tts-workbench:latest
Last Updated2026-08-18
First Seen2026-08-18

Runtime arguments

Web UI
http://[IP]:[PORT:7860]
Network
bridge
Shell
bash
Privileged
false

Template configuration

WebUIPorttcp

TTS Workbench Gradio Web Interface.

Target
7860
Default
7860
Value
7860
Intel GPUDevice

Intel GPU render device. Change this to the renderD### device belonging to your Intel Arc GPU.

Target
/dev/dri/renderD128
Default
/dev/dri/renderD128
Value
/dev/dri/renderD128
ModelsPathrw

Persistent storage for downloaded TTS models.

Target
/models
Default
/mnt/user/AI/tts-workbench/models
Value
/mnt/user/AI/tts-workbench/models
VoicesPathrw

Persistent storage for Kokoro voices and saved voice profiles.

Target
/voices
Default
/mnt/user/AI/tts-workbench/voices
Value
/mnt/user/AI/tts-workbench/voices
InputPathrw

Input storage for reference audio and uploaded files.

Target
/input
Default
/mnt/user/AI/tts-workbench/input
Value
/mnt/user/AI/tts-workbench/input
OutputPathrw

Generated audio output storage. New date folders use the container's local date; existing files and folders are retained.

Target
/output
Default
/mnt/user/AI/tts-workbench/output
Value
/mnt/user/AI/tts-workbench/output
ConfigPathrw

Persistent application configuration storage.

Target
/config
Default
/mnt/user/appdata/tts-workbench
Value
/mnt/user/appdata/tts-workbench