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.

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 |
|
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 soundfileInstall 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-runtime2. 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 soundfileReplace 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.
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):
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:
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:
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 ChineseCosyVoice 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:
Here’s the built-in English voice Aiden reading "Welcome to the bar on the lunar base. What can I get you tonight?":
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 | 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.

