Autumn 2026 · Sent from Tranquility Base
Visit the moon studio ↗
AI tools

Qwen3-TTS Voice Cloning on an Intel GPU: 10x Faster Than a CPU

Clone a voice from 8 seconds of audio. An Intel iGPU takes under 20 s per line, 10x faster than a CPU. XPU setup and cross-lingual tests.

In a studio on the lunar base, an astronaut sits at a laptop with an orange-glowing chip that sends sound waves toward a speaker and a small robot holding a stopwatch
In a studio on the lunar base, an astronaut sits at a laptop with an orange-glowing chip that sends sound waves toward a speaker and a small robot holding a stopwatch

This is the third post in my series on open-source TTS (text-to-speech). I started with an overview in Kokoro TTS vs Chatterbox TTS, and the last post, CosyVoice 3: Free Open-Source AI Voice Cloning That Runs on CPU, covered voice cloning that works even on a CPU. Now it’s Qwen3-TTS’s turn.

In the overview, I ran Qwen3-TTS voice cloning on my CPU, and a single line took more than 4 minutes. My conclusion back then was, "If you need to clone a lot of lines, you still need an NVIDIA GPU." This time I switched to my laptop's Intel integrated GPU, and the same line took just 16 to 18 seconds. In this test, that's more than 10x faster, and I didn't have to modify the package's source code. One caveat: other programs were running during the CPU test, while the iGPU test ran on an otherwise idle machine. Below are the setup steps for Intel integrated graphics (PyTorch XPU), plus a Qwen3-TTS demo cloning my own voice.

What is Qwen3-TTS? Can you use it commercially?

Qwen3-TTS is a family of speech generation models that Alibaba's Qwen team open-sourced on January 22, 2026. The details below come from GitHub and the Hugging Face model page, checked on 2026-11-21:

Item

Details

License

Apache-2.0, commercial use allowed

Sizes

0.6B (600 million parameters) and 1.7B (1.7 billion parameters)

Languages

Chinese, English, Japanese, Korean, German, French, Russian, Portuguese, Spanish, Italian (10 in total)

Voice cloning

Officially, a 3-second reference clip is enough

Training data

The technical report cites more than 5 million hours of speech in 10 languages

Install

pip install -U qwen-tts (I got version 0.1.1)

Three models: Base, CustomVoice, VoiceDesign

Qwen3-TTS comes in three flavors, depending on what you want to do. The "12Hz" in the model names refers to the speech tokenizer it uses:

Model

What it's for

0.6B

1.7B

Tone control with instructions

Base

Voice cloning; can also be fine-tuned

Yes

Yes

No

CustomVoice

9 built-in voices

Yes

Yes

1.7B only

VoiceDesign

Design a new voice from a text description

No

Yes

Yes

All the tests in this post use 0.6B. The Base and CustomVoice downloads from Hugging Face are about 2.4 GB each.

The 9 built-in voices

Here are the built-in CustomVoice voices, based on the official descriptions:

Name

Voice

Native language

Vivian

Bright young female voice with a bit of an edge

Chinese

Serena

Warm, gentle young female voice

Chinese

Uncle_Fu

Mature male voice, deep and mellow

Chinese

Dylan

Young male voice with a Beijing accent

Chinese (Beijing dialect)

Eric

Lively male voice from Chengdu, slightly husky

Chinese (Sichuanese)

Ryan

Male voice with a strong sense of rhythm

English

Aiden

Upbeat American male voice

English

Ono_Anna

Playful, light female voice

Japanese

Sohee

Warm, emotionally rich female voice

Korean

The official advice is to use each voice in its native language for the best results, but every voice can speak all 10 languages.

Hardware: can it run without an NVIDIA GPU?

Yes. The official examples all use device_map="cuda:0" with bfloat16 and FlashAttention 2, and neither GitHub nor the model page mentions CPUs or Intel graphics. In practice, both the CPU and the Intel iGPU can run it.

My laptop has an Intel Core Ultra 5 322 (6 cores) with Panther Lake integrated graphics and no discrete GPU. I used 0.6B to clone my own voice reading the same Chinese line, about 6 seconds long (entered in Simplified Chinese):

Hardware

Generation time

Real-time factor (lower is faster)

CPU (6 cores)

About 270 s

About 42

Intel iGPU (PyTorch XPU)

16 to 18 s

2.7 to 3.0

Intel iGPU, bfloat16

About 12 s

About 2.2

The real-time factor is generation time divided by audio length. A factor of 3.0 means each second of audio takes 3 seconds to generate.

I timed two CPU runs and got 272 seconds and 402 seconds. Other programs were running at the time, which explains the big gap, but either way it took over 4.5 minutes. The iGPU numbers were measured with nothing else running, generating the same line 3 times in a row: the first run required compilation and took about 20 seconds, while the remaining runs took 16 to 18 seconds.

Loading the model takes another 6 to 10 seconds. The built-in voices (CustomVoice) run at a similar speed on the iGPU: a line about 8 seconds long takes about 18 to 20 seconds.

Compared with CosyVoice 3 from the last post, Qwen3-TTS is about 2x faster at voice cloning on the iGPU. I used the same recording and the same two lines for both: Qwen3-TTS took 16 to 28 seconds per line, and CosyVoice 3 took 29 to 61 seconds. (The real-time factor of 2.5 in the CosyVoice 3 post was for cross-lingual mode without a transcript, which is faster than cloning with a transcript.) The gap is even bigger on the CPU: CosyVoice 3 clones a line in about two minutes, while Qwen3-TTS needs over 4.5 minutes. For voice cloning with Qwen3-TTS, the iGPU is close to essential.

Qwen3-TTS install guide (CPU version)

I'm on Linux (Arch) and manage Python with uv. The official recommendation is a fresh Python 3.12 environment.

mkdir -p ~/tools/qwen3-tts && cd ~/tools/qwen3-tts
uv venv --python 3.12 .venv
VIRTUAL_ENV=.venv uv pip install --index-url https://download.pytorch.org/whl/cpu torch torchaudio
VIRTUAL_ENV=.venv uv pip install qwen-tts soundfile

Install torch from PyTorch’s CPU-only index first. Otherwise, the package manager pulls in the CUDA build by default on Linux, which takes up several extra gigabytes.

The official docs also suggest installing FlashAttention 2 for speed, but it's optional and needs a compatible GPU. Neither the CPU nor the Intel iGPU can use it, so you can skip it.

Generating your first line

import torch, soundfile as sf
from qwen_tts import Qwen3TTSModel

# Voice cloning: Base model + reference audio + transcript of the reference audio
m = Qwen3TTSModel.from_pretrained("Qwen/Qwen3-TTS-12Hz-0.6B-Base",
                                  device_map="cpu", dtype=torch.float32)
wavs, sr = m.generate_voice_clone(text="Line to speak", language="Chinese",
                                  ref_audio="ref.wav", ref_text="What the reference audio says")
sf.write("out.wav", wavs[0], sr)

The first run downloads the model from Hugging Face automatically. For the built-in voices, switch to the CustomVoice model:

m = Qwen3TTSModel.from_pretrained("Qwen/Qwen3-TTS-12Hz-0.6B-CustomVoice",
                                  device_map="cpu", dtype=torch.float32)
wavs, sr = m.generate_custom_voice(text="Line to speak", speaker="Uncle_Fu", language="Chinese")

For language, you can use a language name like Chinese, English, or Japanese, or set it to Auto and let the model decide.

Intel iGPU acceleration with PyTorch XPU

This is the heart of the post. PyTorch's backend for Intel graphics is called XPU, and you can install a ready-made XPU build from the official index. No compilation required.

According to PyTorch's official XPU guide, supported Intel graphics include the Arc A and B series discrete GPUs, plus the integrated graphics in Core Ultra chips: Meteor Lake, Arrow Lake, Lunar Lake, and Panther Lake. The officially listed operating systems are Windows 11 and Ubuntu (Panther Lake needs Ubuntu 26.04). I'm on Arch Linux, which isn't on the list, and it still works.

I set up a separate environment just for the iGPU and left the CPU environment alone.

1. Install Intel's compute runtime

A typical desktop system only has the display driver. For PyTorch to run computations on the GPU, you also need Intel's compute runtime (Level Zero). On Arch Linux:

sudo pacman -S intel-compute-runtime

2. Install the XPU build of PyTorch

cd ~/tools/qwen3-tts
uv venv --python 3.12 .venv-xpu
VIRTUAL_ENV=.venv-xpu uv pip install --index-url https://download.pytorch.org/whl/xpu torch torchaudio
.venv-xpu/bin/python -c "import torch; print(torch.xpu.is_available(), torch.xpu.get_device_name(0))"

If it prints True Intel(R) Graphics, PyTorch has found the iGPU. I got PyTorch 2.15.0.

3. Pin the torch version, then install qwen-tts

Installing qwen-tts also triggers a check of the torch dependency. If you let the package manager choose, it may swap the XPU build you just installed for the regular one. So I wrote a constraints file first to pin the versions:

cat > xpu-constraints.txt <<'EOF'
torch==2.15.0+xpu
torchaudio==2.11.1+xpu
EOF

VIRTUAL_ENV=.venv-xpu uv pip install -c xpu-constraints.txt \
  --index-strategy unsafe-best-match --extra-index-url https://download.pytorch.org/whl/xpu \
  qwen-tts soundfile

Replace the version numbers with the ones you actually installed (check with uv pip list). --index-strategy unsafe-best-match lets uv pick packages from both PyPI and PyTorch's XPU index.

With CosyVoice 3, I hit a triton conflict at this step: openai-whisper pulls in an old version of triton, which overwrites the triton-xpu that XPU needs. Qwen3-TTS doesn't use openai-whisper, so I didn't run into it this time. If you see a cannot import name 'make_tensordesc_args' error, the last post explains how to fix it.

4. Change device_map to xpu

This is where it differs most from CosyVoice 3. CosyVoice's code only recognizes CUDA, so I had to load the model on the CPU and then move it to the iGPU by hand. Qwen3-TTS uses the Hugging Face transformers approach to loading models, so you just change device_map to "xpu", with no edits to the package's source code:

m = Qwen3TTSModel.from_pretrained("Qwen/Qwen3-TTS-12Hz-0.6B-Base",
                                  device_map="xpu", dtype=torch.float32)

dtype sets the numerical precision the model uses for computation. float32 uses 32-bit floating-point numbers: high precision, but slower and more memory-intensive. bfloat16 uses only 16 bits: faster and less memory-intensive, but less precise. The official examples use dtype=torch.bfloat16.

I normally use float32, but I also tried bfloat16. Generation time for the same line dropped from 16 to 18 seconds to about 12 seconds, and when I ran it back through speech recognition (Whisper), the text was correct. The two runs produced audio of different lengths, though (5.3 seconds for bfloat16, 6.0 seconds for float32), so keep that in mind when comparing speeds.

I compared the two versions, and the difference in audio quality is small. You have to listen closely to tell them apart. So on an Intel iGPU, I'd just go with bfloat16. In this test, it saved roughly another 30% per line.

The first generation run on the iGPU requires compute kernel compilation, so it’s slower. After that, generation runs at normal speed within the same process. When you generate a batch of lines, load the model once and run the lines one after another. Don't restart the program for every line.

I wrapped both the CPU and iGPU setups into a single command in ~/tools/qwen3-tts/ that I can call from any project. Adding --device xpu switches it to the iGPU environment.

Test 1 (Qwen3-TTS demo): cloning my own voice

The reference clip is the same one from the last post: 8 seconds of my voice, recorded on my phone.

Notice: every audio sample in this section is either my own voice (Terry L) or a clone of it. All rights reserved. Do not download, repost, or use these clips anywhere else, including to clone my voice.
My original recording (8 seconds), in Chinese: "歡迎大家來到我的月球基地。我的文章記錄我對於各種工具的測試,希望對您有幫助。" ("Welcome to my lunar base. My posts document my tests of all kinds of tools, and I hope they help you.") All rights reserved. Do not use elsewhere

I have never said the next two lines. Qwen3-TTS 0.6B generated them in my cloned voice on my Intel iGPU, using the recording above and its transcript. Both the lines and the transcript were converted to Simplified Chinese before being fed into the model (Test 2 explains why):

My cloned voice: "這句話是 Qwen3-TTS 用我錄的八秒鐘聲音克隆出來的。我本人從來沒有念過這句話。" ("This sentence was cloned by Qwen3-TTS from eight seconds of my voice. I have never said it myself.") All rights reserved. Do not use elsewhere
My cloned voice: "這段聲音是在我筆電的 Intel 內顯上生成的,沒有用到 NVIDIA 顯示卡。" ("This audio was generated on my laptop's Intel integrated graphics, without an NVIDIA GPU.") All rights reserved. Do not use elsewhere

The second line is harder. It mixes Chinese and English, with "Intel," "NVIDIA," and the Chinese words for "integrated graphics" and "graphics card." I generated 3 versions in a row. The first two either mispronounced "graphics card" or slurred "NVIDIA," and only the third was fully correct. When you have Qwen3-TTS read lines like this, generate a few versions and pick the best one.

To my ear, the Chinese output sounds a lot like me.

Cross-lingual cloning: using the same Chinese recording, the model can also generate speech in English and Japanese in my voice:

My cloned voice speaking English: "This sentence was generated by Qwen3-TTS from an eight-second clip of my voice. I never actually said it." All rights reserved. Do not use elsewhere
My cloned voice speaking Japanese: "この声は、私の8秒の録音から作られました。" ("This voice was made from an 8-second recording of me.") All rights reserved. Do not use elsewhere

I ran both through speech recognition (Whisper) to check them. The Japanese line was transcribed exactly right. In the English line, everything was correct except the name "Qwen3-TTS," which came out as something else. There were no extra or missing words.

But correct isn't the same as good. To me, the English line sounds choppy, halting, and not very natural. CosyVoice 3 from the last post, using the same recording, is far smoother in English. If you want your own voice to speak other languages, CosyVoice 3 wins on cross-lingual cloning.

Test 2: Arthur’s line, and why I use Simplified Chinese input

The 3D lunar base on my home page is a small game, and it has a bar run by a robot bartender named Arthur. He’s a tribute to the android bartender in the movie Passengers (2016). I deliberately avoid imitating Michael Sheen's voice, and Arthur now speaks in my cloned voice. Here's one of his lines:

My cloned voice, Simplified Chinese input: "酒保是替人保守秘密的。这是这份行业的神圣信用。" ("A bartender keeps people's secrets. That's the sacred trust of the trade.") All rights reserved. Do not use elsewhere

If you have Qwen3-TTS read Chinese, convert the text to Simplified Chinese first. Fed the same line in Traditional Chinese, it misread a word with multiple pronunciations: I heard "行業" (trade) come out as "商議" (to discuss), while the Simplified version got it right. Python's OpenCC package does the conversion in one line:

from opencc import OpenCC
t2s = OpenCC("t2s").convert
text = t2s("這是這份行業的神聖信用")  # Converted to Simplified Chinese

CosyVoice 3 is more convenient here: it reads most Traditional Chinese input correctly as-is, with only the occasional word needing a fix.

Test 3: the 9 built-in voices (CustomVoice)

If you don't want to clone, or you don't have a reference voice for a character yet, you can use the built-in voices. All of these were generated with 0.6B CustomVoice on the iGPU. The line is "歡迎來到月球基地的酒吧。今天想喝點什麼?" ("Welcome to the bar on the lunar base. What would you like to drink today?"), entered in Simplified Chinese:

Built-in voice Uncle_Fu
Built-in voice Vivian
Built-in voice Serena
Built-in voice Dylan (Beijing dialect)
Built-in voice Eric (Sichuanese)

Here’s the built-in English voice Aiden reading "Welcome to the bar on the lunar base. What can I get you tonight?":

Built-in voice Aiden (English)

You can hear Eric's Sichuan accent the moment he starts talking. If you want a character with a bit of a regional accent, he's ready to go.

The 0.6B CustomVoice model doesn’t accept tone instructions. For control like "say it angrily," you need 1.7B.

Qwen3-TTS vs. CosyVoice 3: which one should you use?

Both are open-source models from Alibaba under the Apache-2.0 license, and both allow commercial use. I tested them on the same laptop:

Item

Qwen3-TTS 0.6B

CosyVoice 3 (0.5B)

License

Apache-2.0

Apache-2.0

Languages

10

9 (no Portuguese)

Dialects

Built-in voices for Beijing dialect and Sichuanese

18+, switched with instructions

Chinese input

Convert to Simplified first

Traditional mostly works as-is

Tone control with instructions

Not on 0.6B (1.7B CustomVoice and VoiceDesign can; Base can't)

Yes (dialect, speed, emotion)

Using an Intel iGPU

Just set device_map to "xpu"

Move the model to the iGPU by hand

iGPU cloning, per line (same lines)

16 to 28 s (faster with bfloat16)

29 to 61 s

CPU cloning, per line

Over 4.5 minutes

About 2 minutes

Cross-lingual cloning (Chinese clip speaking English)

Sounds choppy

Far smoother

Here’s how I’d choose:

  • You have an Intel iGPU, want speed, and want to use built-in voices: Qwen3-TTS. It's the simplest to set up and clones faster.
  • You want your own voice to speak English or other languages: CosyVoice 3. Its cross-lingual cloning is far smoother.
  • Your lines are mostly in Traditional Chinese, or you need dialects or emotion instructions: CosyVoice 3. Traditional Chinese input mostly works as-is, and a single instruction can specify Cantonese or Sichuanese, along with speed and emotion.
  • CPU only: CosyVoice 3 clones a line in about two minutes, while Qwen3-TTS takes over 4.5 minutes. If all you have is a CPU, CosyVoice 3 is the more practical choice.

Can you clone someone else's voice?

Technically, yes. All it takes is a clean recording. But only clone your own voice, or a voice whose owner has given you permission. The Apache-2.0 license allows commercial use of the model itself. It doesn't give you the right to use anyone's voice. Celebrities' voices are protected by personality rights, and using someone's voice to say things they never said can also amount to fraud or defamation.

FAQ

Can I use Qwen3-TTS commercially?

Yes. Both the Qwen3-TTS models and the speech tokenizer are licensed under Apache-2.0. But the reference voice has to be your own or one whose owner has given permission.

Can I run Qwen3-TTS without an NVIDIA GPU?

Yes. 0.6B runs on the CPU, but cloning a single line takes several minutes. If you have Intel Core Ultra integrated graphics or an Arc GPU, install the XPU build of PyTorch and set device_map to "xpu". On my laptop, cloning a 6-second line then takes about 16 to 18 seconds, more than 10x faster than the CPU.

Does Qwen3-TTS support English?

Yes. English is one of its 10 supported languages, and Ryan and Aiden are built-in voices whose native language is English. When I had my cloned voice (from a Chinese recording) speak English, though, it sounded choppy. CosyVoice 3 was far smoother.

Can Qwen3-TTS speak Chinese dialects?

Cantonese and Taiwanese Hokkien aren't among its 10 official languages. The only dialects in the built-in voices are Beijing dialect (Dylan) and Sichuanese (Eric). For Cantonese, consider CosyVoice 3, whose dialect instructions include it.

What's the difference between Qwen3-TTS 0.6B and 1.7B?

1.7B adds VoiceDesign (designing a voice from a text description), and its CustomVoice model accepts tone instructions. 0.6B only has voice cloning and the built-in voices. Both sizes support 10 languages.

How long does the reference clip for Qwen3-TTS voice cloning need to be?

Officially, 3 seconds is enough. I used an 8-second recording with a word-for-word transcript. Record in a quiet place, with only one person speaking.

Wrapping up: voice cloning works on Intel integrated graphics too

In the overview post, I assumed that without an NVIDIA GPU, cloning voices with Qwen3-TTS was out of the question. After switching to the Intel iGPU, the same line went from over 4.5 minutes to 16 to 18 seconds, and all I changed was one parameter, device_map. If your laptop has a Core Ultra chip, it's well worth a try.

If you’ve tried Qwen3-TTS or run other AI models on Intel integrated graphics, share your experience with me on Threads or X.