Genie-TTS: a CPU-first ONNX inference engine for GPT-SoVITS

What Genie-TTS solves, and for whom

GPT-SoVITS is a voice cloning and text to speech project, and its original distribution is a PyTorch stack. Running that stack means carrying torch, the model weights, and the associated CUDA or CPU build. Genie-TTS is a separate project that takes the same model family and runs it through ONNX Runtime instead. The README states the goal directly: "Experience near-instantaneous speech synthesis on your CPU". The target user is someone who has GPT-SoVITS checkpoints and wants them in a small runtime, on a machine without a GPU, or inside a Python service that should not pull in torch.

The supported model versions are GPT-SoVITS V2 and V2ProPlus, and the supported languages are Japanese, English, Chinese and Korean. Python must be 3.10 or newer. The package name on PyPI is genie-tts, while the import name is genie_tts. The project also ships a conversion tool, so you are not limited to the models the author distributes. That combination, a converter plus a runtime, is the reason this is more than a wrapper around an ONNX file.

The ONNX path and what the latency table actually says

The README publishes a comparison table with three columns: Genie, the official PyTorch model, and the official ONNX model. First inference latency is listed as 1.13s for Genie, 1.35s for PyTorch, and 3.57s for the official ONNX model. Runtime size is about 200MB for Genie against several GB for PyTorch. Model size is about 230MB for Genie against about 750MB for the official ONNX model. The note under the table says the numbers come from 100 Japanese sentences of roughly 20 characters each, averaged, on an i7-13620H CPU.

Read that note carefully before quoting the table. It is a single machine, one language, and short sentences. It tells you Genie's ONNX build is faster than the official ONNX export on that hardware, which is a plausible outcome if the graph was rewritten for CPU execution. It does not tell you anything about long-form synthesis, Korean or Chinese throughput, or memory under concurrent requests. The README gives no methodology for how the official ONNX number was produced, so the gap between 1.13s and 3.57s is the weakest part of the comparison. Treat the table as the author's own measurement, not as an independent benchmark.

Installing Genie-TTS and running a first synthesis

Installation is a single pip command. The README does not list a conda channel or a source build, so pip is the documented route.

pip install genie-tts

On first run the library needs resource files of about 391MB and will prompt you to download them. If you prefer to fetch them yourself, the README points at the GenieData folder on HuggingFace. The environment variable GENIE_DATA_DIR must be set before the import, because the library reads it at import time.

import os

os.environ["GENIE_DATA_DIR"] = r"C:\path\to\your\GenieData"

import genie_tts as genie

For Chinese prosody there is an optional RoBERTa asset set. The README states it is only for the Chinese path and should not be used for Japanese, English or Korean inference.

import genie_tts as genie

geniedownload_roberta_data()

If you have no model of your own, the project ships predefined characters. The README names Mika (Blue Archive, Japanese), ThirtySeven (Reverse: 1999, English) and Feibi (Wuthering Waves, Chinese), and lists the rest in the CharacterModels folder on HuggingFace.

import genie_tts as genie

genieload_predefined_character('mika')

genietts(
    character_name='mika',
    text='どうしようかな……やっぱりやりたいかも……！',
    play=True,
)

geniewait_for_playback_done()

For your own voice, the flow is three calls: load_character with the ONNX model directory and a language code, set_reference_audio with a clip and its transcript, then tts. The README shows language codes as 'en', 'zh', 'jp' and 'kr'. The reference audio is what carries emotion and intonation, so a mismatched transcript degrades the clone rather than raising an error you can see.

Converting existing GPT-SoVITS checkpoints

The converter is the part that makes Genie usable with models you already trained. It needs torch installed, which is not a base dependency of the package, so you add it yourself.

pip install torch

Then you call convert_to_onnx with a .pth model file, a .ckpt checkpoint file, and an output directory. The README notes that convert_to_onnx currently supports V2 and V2ProPlus.

import genie_tts as genie

genienvert_to_onnx(
    torch_pth_path=r"<YOUR .PTH MODEL FILE>",
    torch_ckpt_path=r"<YOUR .CKPT CHECKPOINT FILE>",
    output_dir=r"<ONNX MODEL OUTPUT DIRECTORY>"
)

Two things are worth flagging. First, the README does not document rollback, a way to verify numerical equivalence between the PyTorch and ONNX outputs, or what happens when a checkpoint is partially incompatible. Second, it does not state whether conversion is deterministic across runs. If you are converting a voice you care about, keep the original checkpoint and compare a rendered sample by ear before deleting anything. That is a gap in the documentation, not a claim that conversion is unreliable.

Serving it: the FastAPI server and the Windows bundles

Genie includes a FastAPI server started from Python rather than a CLI entry point.

import genie_tts as genie

geniestart_server(
    host="0.0.0.0",
    port=8000,
    workers=1
)

The README points to Tutorial/English/API Server Tutorial.py for request formats and API details, and does not reproduce the schema in the main document. That means the routes, payload shape and error responses live in a file in the repository rather than in the README. If you are evaluating this for a service, read that file first, because the top-level README will not tell you whether the API is synchronous, how it handles concurrent synthesis, or what it returns on a bad character name.

For deployment, the roadmap marks out-of-the-box Windows bundles as done and official Docker images as not done. The releases confirm the Windows side: v2.0.2 and v1.0.2 are both described as integrated packages that unzip and run. There is no published Docker image, so containerizing means writing your own Dockerfile around pip install genie-tts plus the model download, and the README does not describe that path.

Limits, failure modes and when this is the wrong tool

The most concrete limitation is version coverage. The roadmap lists V3 and V4 support as unchecked, and the converter note repeats that only V2 and V2ProPlus are supported. If your pipeline is built on a V3 or V4 checkpoint, Genie-TTS cannot convert or load it, and no amount of configuration changes that.

The second is the resource download. About 391MB of files must exist before the first synthesis, either fetched by the library or placed manually and pointed at with GENIE_DATA_DIR. That variable is read before import, so setting it after `import genie_tts` silently does nothing and the library falls back to its own download path. On an air-gapped machine this is the first thing that breaks.

The third is the RoBERTa asset. The README is explicit that it is for the Chinese path only and should not be used for Japanese, English or Korean inference. Feeding it into a non-Chinese run is a documented misuse, not a tuning option.

Finally, the README recommends running in Administrator mode to avoid performance degradation. That is an unusual instruction for a Python library, and the README does not explain the mechanism behind it. If you cannot grant elevated privileges, you have no documented statement about how much performance you lose. This is also not a training tool: it converts and runs models, it does not train them.

How it differs from running GPT-SoVITS or a TorchScript TTS stack directly

The obvious alternative is the upstream GPT-SoVITS project itself. The difference is the execution backend and the dependency footprint. Upstream keeps the PyTorch training and inference code, which is what you need if you intend to fine-tune a voice. Genie drops training entirely and runs a converted ONNX graph, which is why the runtime is around 200MB instead of several gigabytes. You trade the ability to train for a smaller deployment and, per the author's table, lower first-token latency on CPU.

A second alternative is the official ONNX export maintained in the GPT-SoVITS ecosystem. Genie's table puts that export at 3.57s first inference and about 750MB of model size, against 1.13s and about 230MB. Both are ONNX, so the difference is in how the graph and the auxiliary assets are packaged, not in the format. If you already have a working official ONNX export and it meets your latency budget, switching buys you the converter and the FastAPI server more than it buys you speed.

A third option is any of the other TTS projects people search alongside this one, such as Tortoise-TTS or a generation web UI. Those are different model families with their own voice cloning behaviour, and the README makes no comparison to them. Genie's only claim is about GPT-SoVITS checkpoints on CPU.

Editorial conclusion

Adopt Genie-TTS if you already have GPT-SoVITS V2 or V2ProPlus checkpoints and want them running on CPU through ONNX Runtime, with a FastAPI server or a bundled Windows package. Do not adopt it if you need V3 or V4 checkpoints, GPU training, or an official Docker image, none of which the repository offers today. Before committing, convert one of your own .pth and .ckpt pairs with convert_to_onnx and listen to the output, because the README does not document conversion fidelity for non-Japanese text.

Frequently asked questions

Official sources

1. High-Logic/Genie-TTS on GitHub
2. Issues
3. License: MIT
4. README
5. Releases