You need to agree to share your Hugging Face information to access this model

This repository is publicly accessible, but you have to accept the conditions to access its files and content.

OhanTTS is released under the CC BY-NC 4.0 license for research, educational, and other non-commercial use. By requesting access, you agree to use the model only in accordance with this license and to use reference voices only with the speaker's permission.

Log in or Sign Up to review the conditions and access this model content.

OhanTTS-v0.1

OhanTTS Armenian Speech Generation

An Armenian-focused streaming text-to-speech model. It supports reference voice cloning, code-switching, and audio generation up to about 20 seconds. For voice cloning, use a reference audio clip around 3–10 seconds long.

Supported languages

Armenian, English, Spanish, Arabic, Russian, Mandarin Chinese, Japanese, and French.

Usage

SGLang Usage

SGLang-Omni is a serving framework for multimodal models. It serves OhanTTS with continuous batching and streams speech through the OpenAI-compatible /v1/audio/speech endpoint.

See the OhanTTS cookbook for setup, server launch, and streaming request examples.

Install from source

Clone the SGLang-Omni repository and install it in a Python 3.12 virtual environment. Follow the installation guide for platform prerequisites and SGLang setup.

git clone https://github.com/Metric-AI-Lab/sglang-ohan.git
cd sglang-omni
python -m venv .venv
source .venv/bin/activate
pip install uv
uv pip install --prerelease=allow -e .

Serve

After installing the SGLang integration, run:

sgl-omni serve \
  --model-path Metric-AI/OhanTTS-v0.1 \
  --port 8000 \
  --allowed-local-media-path /absolute/path/to/references

Voice cloning

Send a reference WAV recording and its exact transcript with the synthesis request:

Call the server with curl

Replace the reference path and transcript with your own. The WAV must be on the server, inside the directory set by --allowed-local-media-path. The command saves the generated speech to output.wav.

curl --fail-with-body -X POST http://127.0.0.1:8000/v1/audio/speech \
  -H 'Content-Type: application/json' \
  -d '{
    "input": "Replace this with the Armenian text you want the model to say.",
    "references": [{
      "audio_path": "/absolute/path/to/references/reference.wav",
      "text": "Exact transcript of reference.wav"
    }],
    "response_format": "wav"
  }' \
  --output output.wav
Call the server with Python

This example sends the WAV in the request, so it also works when the reference file is only on the client. For this method, --allowed-local-media-path is optional.

import base64
from pathlib import Path

import requests

response = requests.post(
    "http://127.0.0.1:8000/v1/audio/speech",
    json={
        "input": "Replace this with the Armenian text you want the model to say.",
        "references": [{
            "data": base64.b64encode(Path("reference.wav").read_bytes()).decode("ascii"),
            "media_type": "audio/wav",
            "text": "Replace this with the exact transcript of your reference recording.",
        }],
    },
)
response.raise_for_status()
Path("output.wav").write_bytes(response.content)

For streaming, use "stream": true and "response_format": "pcm" in the request body. Streamed PCM is mono, signed 16-bit audio at 24 kHz.

Evaluation

Audio Length
Mean generated target audio in evaluation 8.55 seconds
Metric Result
Mean per-clip WER 14.70%
Mean per-clip CER 6.15%
Mean SIM-o 0.6930
  • WER: Compares the words recognized from generated audio with the requested text; lower is better.
  • CER: The same comparison at the character level; lower is better.
  • SIM-o: Compares the generated voice with the reference speaker using audio embeddings; higher means more similar.

Streaming performance

Measured on one shared NVIDIA GB10 over local HTTP with streamed PCM output. The benchmark used this checkpoint on the local main integration with max_running_requests=64, cuda_graph_max_bs=64, CUDA graphs enabled, and 8/20/4 decoding. These measurements cover OhanTTS only.

Client concurrency Throughput (req/s) Mean TTFA Mean full response latency Mean RTF Audio seconds/s
1 0.69 331 ms 1,447 ms 0.178 5.59
2 0.90 464 ms 1,812 ms 0.236 7.30
4 1.36 651 ms 2,256 ms 0.302 11.02
8 1.88 1,142 ms 3,580 ms 0.505 15.33
16 2.52 2,169 ms 5,639 ms 0.841 20.52

License

OhanTTS-v0.1 is released under CC BY-NC 4.0. It is adapted from k2-fsa/OmniVoice (CC BY-NC) and uses the Higgs Audio V2 tokenizer, which is subject to Boson AI's license.

Acknowledgements

We acknowledge the EuroHPC Joint Undertaking for awarding this project access to the EuroHPC supercomputer LUMI, hosted by CSC (Finland) and the LUMI consortium. OhanTTS-v0.1 was trained on LUMI.

Citation

If you use OhanTTS-v0.1 in your research, please cite it as follows:

@misc{ohantts2026,
  title={OhanTTS: Armenian-Focused Streaming Text-to-Speech},
  author={Minasyan, Bagrat and Khurshudyan, Anna},
  publisher={Metric AI Lab},
  year={2026},
  howpublished={\url{https://huggingface.co/Metric-AI/OhanTTS-v0.1}},
  note={Version 0.1}
}
Downloads last month
9
Safetensors
Model size
0.8B params
Tensor type
I64
·
F32
·
Inference Providers NEW
This model isn't deployed by any Inference Provider. 🙋 Ask for provider support

Collection including Metric-AI/OhanTTS-v0.1

Article mentioning Metric-AI/OhanTTS-v0.1