Kimi-Audio is Moonshot AI's open-source audio foundation model. A single 7B model handles speech recognition, audio understanding, audio generation, and end-to-end voice conversation. The official code targets Linux, so this guide walks Windows users through the setup paths that actually work reliably in 2026 — WSL2, Docker, and the caveats around a native install.
Quick answer. Kimi-Audio, Moonshot AI's open-source audio model, runs best on Windows through WSL2 or Docker rather than a native install, because the repository targets Linux. You need an NVIDIA GPU with 24GB+ VRAM, CUDA 12.1+, Python 3.10, and the Kimi-Audio-7B-Instruct weights from Hugging Face.
What is Kimi-Audio?
Kimi-Audio is a universal audio foundation model released by Moonshot AI (the lab behind the Kimi chat models). It was pre-trained on more than 13 million hours of audio — speech, music, and general sound — plus text, so one model can transcribe, caption, answer questions about audio, recognize speech emotion, and hold a spoken conversation.
The publicly released checkpoint is moonshotai/Kimi-Audio-7B-Instruct on Hugging Face, with training code, weights, and an evaluation toolkit on GitHub. Moonshot reports state-of-the-art word error rates on LibriSpeech (about 1.28 WER on test-clean and 2.42 on test-other) alongside strong results on audio-understanding and voice-conversation benchmarks. Because it comes from the same lab as the flagship text model, you can pair it with the Kimi K2.6 guide if you want a full picture of the Kimi family.
What do you need to run Kimi-Audio on Windows?
Hardware
- GPU: NVIDIA GPU with 24GB+ VRAM (RTX 4090 or RTX 3090 recommended). The 7B model plus its audio tokenizer/detokenizer is heavy; less than 24GB forces aggressive offloading.
- RAM: 32GB system memory minimum.
- Storage: ~50GB free on an SSD (weights, CUDA, and cache).
- OS: Windows 10 or 11, 64-bit, with WSL2 enabled.
Software
- Python 3.10
- CUDA 12.1+ with a matching NVIDIA driver
- PyTorch 2.1+ built for CUDA
- FFmpeg
- Git
Kimi-Audio's dependencies (including its custom CUDA/Triton kernels) are built and tested on Linux. On Windows the dependable route is WSL2 or a Docker container. A purely native Windows install is possible but brittle, so treat it as a last resort.
How do you install Kimi-Audio on Windows?
Method 1: WSL2 + Ubuntu (recommended)
Step 1 — Install WSL2 and Ubuntu. In an elevated PowerShell:
wsl --install -d Ubuntu-22.04
wsl --set-default-version 2Reboot if prompted, then open the Ubuntu terminal. Make sure you have a recent NVIDIA Windows driver installed on the host — that driver exposes the GPU to WSL2; you do not install a separate Linux GPU driver inside WSL.
Step 2 — Install system packages inside Ubuntu.
sudo apt update && sudo apt install -y python3.10 python3.10-venv python3-pip git ffmpegStep 3 — Create a virtual environment and install PyTorch with CUDA.
python3.10 -m venv kimi-env
source kimi-env/bin/activate
pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu121Step 4 — Clone Kimi-Audio and install its requirements.
git clone https://github.com/MoonshotAI/Kimi-Audio
cd Kimi-Audio
pip install -r requirements.txtVerify the GPU is visible from inside WSL with nvidia-smi before you continue.
Method 2: Docker Desktop
If you would rather not manage the environment by hand, use the Dockerfile shipped in the repo.
Step 1 — Install Docker Desktop with the WSL2 backend enabled, and allocate 8GB+ RAM to Docker in its settings. Install the NVIDIA Container Toolkit so containers can access the GPU.
Step 2 — Build the image from the cloned repo directory:
docker build -t kimi-audio:v0.1 .Step 3 — Run the container with GPU passthrough:
docker run --gpus all -it kimi-audio:v0.1Method 3: Native Windows (last resort)
You can attempt a native install with Chocolatey, but expect to patch Linux-only assumptions in the dependency chain. Only take this path if WSL2 and Docker are both unavailable to you.
# Install Chocolatey, then the toolchain
Set-ExecutionPolicy Bypass -Scope Process -Force
[System.Net.ServicePointManager]::SecurityProtocol = [System.Net.SecurityProtocolType]::Tls12
iex ((New-Object System.Net.WebClient).DownloadString('https://community.chocolatey.org/install.ps1'))
choco install git python310 cuda ffmpeg -y
# Environment + PyTorch
python -m venv kimi-env
.\kimi-env\Scripts\activate
pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu121How do you download the Kimi-Audio model?
Pull the instruct checkpoint from Hugging Face (run huggingface-cli login first if the download stalls on auth):
huggingface-cli login
huggingface-cli download moonshotai/Kimi-Audio-7B-Instruct --local-dir ./models/Kimi-Audio-7B-InstructIf you prefer a config file over hard-coded paths, create a .env in the project root:
MODEL_PATH=./models/Kimi-Audio-7B-Instruct
DEVICE=cuda
PRECISION=bf16How do you transcribe audio with Kimi-Audio?
The most common task is speech-to-text (ASR). Point the model at a WAV file and request text output:
import torch
from kimia_infer.api.kimia import KimiAudio
# Load the model
model_id = "moonshotai/Kimi-Audio-7B-Instruct"
device = "cuda" if torch.cuda.is_available() else "cpu"
model = KimiAudio(model_path=model_id, load_detokenizer=True)
# Sampling parameters
sampling_params = {
"audio_temperature": 0.8,
"audio_top_k": 10,
"text_temperature": 0.0,
"text_top_k": 5,
"audio_repetition_penalty": 1.0,
"audio_repetition_window_size": 64,
"text_repetition_penalty": 1.0,
"text_repetition_window_size": 16,
}
# Audio-to-text (ASR)
messages_asr = [
{"role": "user", "message_type": "text", "content": "Please transcribe the following audio:"},
{"role": "user", "message_type": "audio", "content": "asr_example.wav"},
]
_, text_output = model.generate(messages_asr, **sampling_params, output_type="text")
print("ASR output:", text_output)How do you run voice conversations with Kimi-Audio?
Kimi-Audio can answer a spoken question with both audio and text. Ask for output_type="both" and save the returned waveform:
import soundfile as sf
qa_audio_path = "qa_example.wav"
messages_conversation = [
{"role": "user", "message_type": "audio", "content": qa_audio_path},
]
wav_output, text_output = model.generate(messages_conversation, **sampling_params, output_type="both")
# Save the generated reply (24kHz)
sf.write("output_audio.wav", wav_output.detach().cpu().view(-1).numpy(), 24000)
print("Reply text:", text_output)How can you optimize Kimi-Audio performance?
If you are close to your VRAM ceiling, a few levers help:
- Use bf16 precision (set
PRECISION=bf16) instead of fp32 to roughly halve memory use. - Enable gradient checkpointing when fine-tuning to trade compute for memory:
model.gradient_checkpointing_enable(). - Run under mixed precision with
torch.autocast("cuda", dtype=torch.bfloat16)around generation. - Shorten inputs — audio length drives token count, so chunk long files rather than feeding one long clip.
If you still hit CUDA out of memory, drop batch size to 1 and close other GPU processes before retrying.
How does Kimi-Audio compare to Whisper?
Whisper is transcription-only and light on hardware; Kimi-Audio is a broader model that also generates audio and holds voice conversations, at the cost of far more VRAM. Pick based on the task, not on a single accuracy figure.
| Capability | Kimi-Audio-7B | Whisper large-v3 |
|---|---|---|
| Speech recognition (ASR) | Yes — reports ~1.28 WER on LibriSpeech test-clean | Yes |
| Audio generation | Yes | No |
| Speech-to-speech conversation | Yes | No |
| Approx. VRAM to run | 24GB+ | ~10GB |
Troubleshooting common Kimi-Audio errors on Windows
| Error | Fix |
|---|---|
| CUDA out of memory | Drop batch size to 1, use bf16, enable gradient checkpointing |
| FFmpeg not found | Install it: sudo apt install ffmpeg (WSL) or choco install ffmpeg |
| DLL load failed / no CUDA device | Update the NVIDIA Windows driver; confirm nvidia-smi works in WSL |
| Tokenizer / cache errors | Clear the Hugging Face cache: rm -r ~/.cache/huggingface |
FAQ
Can you run Kimi-Audio on Windows without WSL?
Technically yes, but it is not recommended. The repository and its custom kernels are built for Linux, so a native Windows install usually requires patching dependencies by hand. WSL2 or Docker gives you the tested Linux environment on the same machine with far less friction.
How much VRAM does Kimi-Audio need?
Plan for a 24GB+ NVIDIA GPU such as an RTX 4090 or 3090. The 7B model plus its audio detokenizer is memory-heavy; below 24GB you rely on offloading and bf16 precision, which slows generation.
Is Kimi-Audio free to use?
Yes. Moonshot AI open-sourced the weights, training code, and evaluation toolkit. You download Kimi-Audio-7B-Instruct from Hugging Face and run it locally at no cost — you only pay for the hardware or cloud GPU you run it on.
What can Kimi-Audio do besides transcription?
Beyond ASR it handles audio captioning, audio question answering, speech emotion recognition, sound classification, and end-to-end speech-to-speech conversation, and it can generate audio output — all from the same 7B model.
Can you run Kimi-Audio without a GPU?
The code will fall back to CPU, but for a 7B audio model that is impractically slow for real use. Treat a capable NVIDIA GPU (or a rented cloud GPU) as a requirement rather than an option.