# Install VoiceBox from PyPI
pip install voicebox-ai

# Verify installation
voicebox --version

# Initialize the application
voicebox init --model qwen3-tts

# Clone the repository
git clone https://github.com/jamiepine/voicebox.git
cd voicebox

# Create a virtual environment
python -m venv .venv
source .venv/bin/activate

# Install dependencies
pip install -r requirements.txt

# Install the package in development mode
pip install -e .

# Download the default voice models
voicebox download-models --all

# Pull the official image
docker pull jamiepine/voicebox:latest

# Run with GPU support (NVIDIA)
docker run -d \
  --name voicebox \
  --gpus all \
  -p 8000:8000 \
  -v ${HOME}/voicebox-data:/data \
  -e VOICEBOX_MODEL=qwen3-tts \
  jamiepine/voicebox:latest

# Run on Apple Silicon (no GPU flag needed)
docker run -d \
  --name voicebox \
  -p 8000:8000 \
  -v ${HOME}/voicebox-data:/data \
  -e VOICEBOX_MODEL=qwen3-tts \
  jamiepine/voicebox:latest

# Install Python 3.11+ from microsoft store
# Then install VoiceBox
pip install voicebox-ai

# For GPU acceleration, install CUDA toolkit
# Download from: https://developer.nvidia.com/cuda-downloads

# Initialize VoiceBox
voicebox init --gpu cuda

# Record audio using the built-in recorder
voicebox record --output sample.wav --duration 30

# Or upload an existing audio file
voicebox clone --audio my_voice_sample.mp3 --name "my-voice"

# VoiceBox automatically processes the audio and extracts voice characteristics

from voicebox.engine import VoiceCloner
from voicebox.audio import AudioProcessor

# Initialize the cloner
cloner = VoiceCloner(model="qwen3-tts-voice-clone")

# Load and preprocess the reference audio
processor = AudioProcessor()
reference = processor.load_audio("sample.wav")
reference = processor.normalize(reference, target_rms=-20)
reference = processor.remove_noise(reference, method="spectral")

# Extract voice embeddings
embeddings = cloner.extract_embeddings(reference)

# Create the voice model
voice_model = cloner.create_voice(
    embeddings=embeddings,
    name="my-voice",
    quality="high"
)

# Test the cloned voice
output = voice_model.synthesize(
    text="Hello, this is my cloned voice speaking.",
    speed=1.0,
    emotion="neutral"
)
voice_model.save(output, "test_output.wav")

# Control speech rate
voicebox synthesize --input script.txt --output speech.wav --speed 0.8

# Add emotional inflection
voicebox synthesize --input script.txt --output emotional.wav --emotion happy

# Adjust pitch
voicebox synthesize --input script.txt --output pitched.wav --pitch +200

# Combine multiple parameters
voicebox synthesize \
  --input script.txt \
  --output natural.wav \
  --speed 1.1 \
  --pitch +100 \
  --emotion confident \
  --clarity high

from voicebox.engine import VoiceManager

manager = VoiceManager()

# List all cloned voices
voices = manager.list_voices()
for v in voices:
    print(f"{v.name}: {v.quality} ({v.duration}s of training data)")

# Switch between voices
manager.set_active_voice("my-voice")
output = manager.synthesize("Hello from my cloned voice!")

# Blend two voices for hybrid speech
hybrid = manager.blend_voices(
    voice_a="my-voice",
    voice_b="partner-voice",
    weight_a=0.7,
    weight_b=0.3
)
output = hybrid.synthesize("Blended voice output")

# Enable system-wide dictation
voicebox dictation --enable

# Choose the recognition model
voicebox dictation --model whisper-large-v3

# Set the output language
voicebox dictation --language en

# Configure hotkey
voicebox dictation --hotkey "ctrl+space"

from voicebox.dictation import DictationEngine

# Initialize the dictation engine
engine = DictationEngine(
    model="whisper-large-v3",
    language="auto",
    beam_size=5,
    vad_threshold=0.5
)

# Start listening
engine.start_listening(
    hotkey="ctrl+shift+d",
    output_mode="clipboard",
    append_mode=True
)

# Process a dictation session
result = await engine.listen_session(
    timeout=300,           # 5 minute session
    silence_threshold=1.5, # Stop after 1.5s of silence
    language="en"
)

print(f"Transcribed: {result.text}")
print(f"Confidence: {result.confidence:.2%}")
print(f"Words: {result.word_count}")

# Enable auto-detection
voicebox dictation --auto-detect

# Specify supported languages
voicebox dictation --languages en,zh,ko,ja,es,fr,de

# Set primary language (for better accuracy)
voicebox dictation --primary-language en

# Simple text-to-speech conversion
curl -X POST "https://your-voicebox/api/v1/tts" \
  -H "Content-Type: application/json" \
  -d '{
    "text": "Hello, this is a test of VoiceBox text-to-speech.",
    "voice": "default",
    "speed": 1.0,
    "output_format": "wav"
  }' \
  --output speech.wav

# Stream audio in chunks
curl -N -X POST "https://your-voicebox/api/v1/tts/stream" \
  -H "Content-Type: application/json" \
  -d '{"text": "This audio will stream in real-time...", "voice": "cloned-voice"}' \
  --output - | aplay

from voicebox.api import VoiceBoxClient

client = VoiceBoxClient("https://your-voicebox")

texts = [
    "First sentence for processing.",
    "Second sentence with different content.",
    "Third sentence in another voice.",
]

results = await client.tts.batch(
    texts=texts,
    voice="default",
    output_format="mp3",
    parallel_workers=4
)

for i, result in enumerate(results):
    print(f"Generated: speech_{i}.mp3 ({result.duration:.1f}s)")

import voicebox

# Quick TTS
result = voicebox.synthesize(
    text="Hello from VoiceBox!",
    voice="default",
    output_file="hello.wav"
)

# Voice cloning from audio file
cloned = voicebox.clone_voice(
    audio_file="sample.wav",
    voice_name="my-voice"
)

# Dictation into clipboard
voicebox.start_dictation(
    hotkey="cmd+space",
    target_app="any"
)

# Generate audio from a text file
voicebox tts --file script.txt --output narration.wav

# Clone a voice from a podcast episode
voicebox clone --audio podcast_ep1.mp3 --name "podcaster"

# Convert text to multiple languages
for lang in en zh ko vi; do
  voicebox tts --text "Hello world" --lang $lang --output greeting_$lang.wav
done

# Batch process a directory of text files
voicebox tts-batch --input ./scripts/ --output ./audio/ --voice default

# Clone your voice from existing podcast episodes
voicebox clone --audio ~/podcasts/episodes/*.mp3 --name "my-podcast-voice"

# Generate English version
voicebox tts --file article_en.txt --voice "my-podcast-voice" --output podcast_en.wav

# Generate Chinese version (requires translation first)
voicebox tts --file article_zh.txt --voice "my-podcast-voice" --output podcast_zh.wav

# Generate Korean version
voicebox tts --file article_ko.txt --voice "my-podcast-voice" --output podcast_ko.wav

# Record a few seconds of natural speech
voicebox record --output baseline.wav --duration 10

# Clone the voice
voicebox clone --audio baseline.wav --name "accessible-voice"

# Use the cloned voice for text-to-speech
voicebox tts --text "I would like water please" --voice "accessible-voice" --output response.wav

# Generate a voiceover for a video script
voicebox tts \
  --file video_script.txt \
  --voice "professional-narrator" \
  --speed 1.05 \
  --emotion engaging \
  --output voiceover.wav

# Add background music mix
ffmpeg -i voiceover.wav -i background_music.mp3 \
  -filter_complex "[0:a][1:a]amix=inputs=2:duration=first" \
  -output final_video_audio.mp3

# 1. Install VoiceBox
pip install voicebox-ai

# 2. Initialize with default model
voicebox init --model qwen3-tts

# 3. Download voice models
voicebox download-models --all

# 4. Test basic TTS
echo "Hello World" | voicebox tts --output test.wav

# 5. Set up dictation
voicebox dictation --enable --hotkey "ctrl+space"

# 6. Start web interface
voicebox web --port 8000