How to run LatentSync lip sync on a cloud GPU
Rent a GPU on Deploy, then open a terminal in JupyterLab or over SSH. Clone the official bytedance/LatentSync repository and enter it, then install the way setup_env.sh prints, which downloads the checkpoints the script names, and run ./inference.sh or python gradio_app.py from that directory. Copy the mp4 off the instance before you destroy it, because destroying the instance deletes its disk.
Semi-body animation whose README lists tested GPUs as A100(80G), RTX4090D (24G), and V100(16G) is How to run EchoMimicV2 on a cloud GPU. Lip sync from a face video and an audio file, a different repository whose README prints no GPU GB figure, is How to run Wav2Lip on a cloud GPU. Audio-driven lip sync from a different repository is How to run MuseTalk on a cloud GPU. A single-image talking head from a different repository whose README prints no GPU GB figure is How to run SadTalker on a cloud GPU. If the process runs out of memory: How to fix CUDA out of memory on a cloud GPU. The Gradio launch call does not pass a port. The tunnel page is How to use SSH port forwarding on a cloud GPU.
Only animate a face you have the right to use. The repository LICENSE file is the Apache License, Version 2.0. The appendix copyright line is still the unfilled template Copyright [yyyy] [name of copyright owner]. The GitHub license field on 2026-11-13 was Apache-2.0. The model card for ByteDance/LatentSync-1.6 that day had cardData.license openrail++, top-level license null, and gated false, lastModified 2025-06-12T09:10:55.000Z. The card README this page read prints no GPU GB figure. This page does not paste the OpenRAIL++ clauses. Read the repository file and the card before you redistribute the program or the weights.
The commands below are copied from the upstream files named in each step. They were not run on a CloudGPU instance for this page. Anything this page adds around them is marked.
What the README says about memory
The inference section says minimum VRAM for inference is 8 GB with LatentSync 1.5 and 18 GB with LatentSync 1.6 (read 2026-11-13). The training section prints separate figures: stage1.yaml requires 23 GB, stage2.yaml requires 30 GB, stage2_efficient.yaml requires 20 GB, stage1_512.yaml requires 30 GB, and stage2_512.yaml requires 55 GB. The 1.5 update says that release reduces the VRAM requirement of the stage2 training to 20 GB. The stage2_efficient.yaml sentence names the RTX 3090. Those sentences are the README’s. This page did not remeasure them and did not train.
configs/unet/stage2_512.yaml sets resolution to 512. configs/unet/stage2.yaml sets resolution to 256. inference.sh and gradio_app.py both load configs/unet/stage2_512.yaml. The 55 GB line is the README’s training line for that file. The 18 GB line is the README’s inference line for LatentSync 1.6. This page does not treat those two numbers as the same measurement.
GET /v1/public/compute-capabilities does not list GPUs. It returns feature flags. The memory column is vram_gb from gpu-prices.json, updated_at 2026-11-13T12:00:35.593Z. GET /v1/public/gpu-catalog the same day (generated_at 2026-11-13T12:00:36.648Z) listed the same names and the same vram_gb values, plus Ascend 910B at 64, which is not in gpu-prices.json and is not listed here. The catalog response also includes an availability field. This page does not copy it. Every prices row has gpu_count 1. The smallest vram_gb in that file is 8, on RTX 2080. Catalog rows whose vram_gb is below 18 are RTX 2080 (8), RTX 3080 (10), RTX 2080 Ti (11), RTX 3080 Ti (12), and V100 16G (16). Catalog RTX 3090 is 24. Those catalog numbers are not the README’s measurements. This page did not run LatentSync and does not mark a row as enough. Which listing you can start is on Deploy.
The catalog template list had no LatentSync template.
| Catalog name | vram_gb |
|---|---|
| RTX 2080 | 8 |
| RTX 3080 | 10 |
| RTX 2080 Ti | 11 |
| RTX 3080 Ti | 12 |
| V100 16G | 16 |
| A30 | 24 |
| RTX 3090 | 24 |
| RTX 4090 | 24 |
| RTX 4090D | 24 |
| RTX 4080 SUPER 32G | 32 |
| RTX 5090 | 32 |
| RTX 5090D | 32 |
| V100 32G | 32 |
| A100 40G | 40 |
| A800 40G | 40 |
| A40 | 48 |
| RTX 4090 48G | 48 |
| RTX 4090D 48G | 48 |
| RTX A6000 | 48 |
| NVIDIA RTX PRO 5000 72G | 72 |
| RTX PRO 5000 72G | 72 |
| A100 80G | 80 |
| A800 80G | 80 |
| H800 | 80 |
| RTX 6000D | 83 |
| H20 96G | 96 |
| RTX PRO 6000 96G | 96 |
| RTX PRO 6000 Max-Q | 96 |
| H20-3e 141G | 141 |
Install
On Deploy, choose Raw GPU. The README does not print a git clone. This page adds the clone and the directory change, and they were not run. The install script, the inference script, and the Gradio app are files in that checkout, so the commands below are run from that directory.
# The next two lines are added on this page. The README does not print a clone command.
git clone https://github.com/bytedance/LatentSync.git
cd LatentSync
The README install is source setup_env.sh. The script, copied. A conda environment is the script’s first step: How to set up a conda environment on a cloud GPU. The download lines use huggingface-cli: How to download a Hugging Face model on a cloud GPU.
conda create -y -n latentsync python=3.10.13
conda activate latentsync
conda install -y -c conda-forge ffmpeg
pip install -r requirements.txt
sudo apt -y install libgl1
huggingface-cli download ByteDance/LatentSync-1.6 whisper/tiny.pt --local-dir checkpoints
huggingface-cli download ByteDance/LatentSync-1.6 latentsync_unet.pt --local-dir checkpoints
The README says a successful download looks like this:
./checkpoints/
|-- latentsync_unet.pt
|-- whisper
| `-- tiny.pt
requirements.txt pins torch==2.5.1, torchvision==0.20.1, and --extra-index-url https://download.pytorch.org/whl/cu121. It also pins gradio==5.24.0 and huggingface-hub==0.30.2. The introduction links a speech-model repository. This page does not print that URL. Copy it from the README if you need it. The file the script downloads is whisper/tiny.pt inside ByteDance/LatentSync-1.6. A badge on the README links a hosted demo. This page does not print that repository. A parenthetical under the demo table names a research-project page. This page does not print that URL.
The commits API for the default branch main listed a229c3948406bc2cf6eaf4873e662e70c6a04746, committed 2025-06-20T07:36:51Z. setup_env.sh was d058a6146983053d07239440fc62be16102d1e86, committed 2025-06-11T12:32:04Z. requirements.txt was 404e34d4ac66a64851dac23f301b20bee0b3cda9, committed 2025-04-22T10:36:46Z.
The RTX 5090 guide says that card is compute capability 12.0 (sm_120) and that PyTorch 2.7 and later, on a build for CUDA 12.8 or newer, is the line that announced support. requirements.txt pins torch==2.5.1 and the cu121 index. This page does not change that pin and did not re-test LatentSync on an RTX 5090. Catalog RTX 5090 and RTX 5090D are 32. That is the catalog number only.
Inference
The README’s command-line path, copied:
./inference.sh
inference.sh, copied. --video_out_path is the relative path video_out.mp4. --inference_steps is 20 and --guidance_scale is 1.5. The README says inference_steps is in the range 20-50 and guidance_scale is in the range 1.0-3.0.
python -m scripts.inference \
--unet_config_path "configs/unet/stage2_512.yaml" \
--inference_ckpt_path "checkpoints/latentsync_unet.pt" \
--inference_steps 20 \
--guidance_scale 1.5 \
--enable_deepcache \
--video_path "assets/demo1_video.mp4" \
--audio_path "assets/demo1_audio.wav" \
--video_out_path "video_out.mp4"
scripts/inference.py requires --video_out_path and passes it through. This page did not run the script, so it does not state that a file appeared.
The model card says the current code is compatible with LatentSync 1.5 and 1.6, and that switching versions means loading the corresponding checkpoint and modifying the resolution parameter in the U-Net config. setup_env.sh downloads ByteDance/LatentSync-1.6 only. This page does not print a different checkpoint id.
Gradio
The README’s app command, copied:
python gradio_app.py
gradio_app.py calls demo.launch(inbrowser=True, share=True). The call does not pass server_name or server_port. This page does not state a port number and did not start the app. process_video creates ./temp and sets the output path to ./temp/{video stem}_{YYYYMMDD_HHMMSS}.mp4. The slider for inference steps runs from 10 to 50 and defaults to 20. The README’s inference-step range is 20-50. Those two files do not print the same minimum. Guidance scale in the app runs from 1.0 to 3.0 and defaults to 1.5, which matches the README’s range and the script’s 1.5. The seed number in the app is 1247.
ComfyUI
The README does not document a ComfyUI install. The ComfyUI examples top-level directory list on 2026-11-13 had no directory named for this project. Examples HEAD was f9431bb000ce792094ff345446e22cac1ea6cef3, committed 2025-11-26T20:33:58Z. Installing ComfyUI itself is How to install ComfyUI and ComfyUI-Manager on a cloud GPU. This page does not add a ComfyUI install.
When it fails
CUDA out of memory. The README’s inference lines are 8 GB for LatentSync 1.5 and 18 GB for LatentSync 1.6. The training lines are the separate GB figures in the memory section. If the process raises that error, use how to fix CUDA out of memory on a cloud GPU.
“CUDA error: no kernel image is available for execution on the device” on an RTX 5090. See the install section. This page did not re-test the pinned torch build on that card.
Save the video, then destroy
inference.sh passes --video_out_path "video_out.mp4", a path relative to the working directory. The Gradio function writes ./temp/{video stem}_{YYYYMMDD_HHMMSS}.mp4. Checkpoints from setup_env.sh are under ./checkpoints/. Copy the files you want before you destroy the instance. Save your work before you destroy a cloud GPU is the checklist. The terms say data on local instance storage is permanently deleted when the instance is destroyed.
The pricing page FAQ states the billing rule in these words:
Per-minute options have a 1-minute minimum; unused prepaid minutes are refunded when you destroy the instance. Some configurations use whole-hour billing with a 1-hour minimum; unused time within a charged hour is not refunded on voluntary stop. The billing period, minimum charge and initial prepayment are shown before confirmation. No subscription.
Frequently asked questions
What GPU memory figures does the LatentSync documentation state?
The README says minimum VRAM for inference is 8 GB with LatentSync 1.5 and 18 GB with LatentSync 1.6. The training section says stage1.yaml requires 23 GB, stage2.yaml requires 30 GB, stage2_efficient.yaml requires 20 GB, stage1_512.yaml requires 30 GB, and stage2_512.yaml requires 55 GB. The 1.5 update says stage2 training was reduced to 20 GB. inference.sh loads configs/unet/stage2_512.yaml, whose resolution field is 512. The 55 GB line is the training line for that file. The 18 GB line is the inference line for version 1.6. The model card README this page read prints no GPU GB figure. Catalog rows whose vram_gb is below 18 are RTX 2080 at 8, RTX 3080 at 10, RTX 2080 Ti at 11, RTX 3080 Ti at 12, and V100 16G at 16, in gpu-prices.json (updated_at 2026-11-13T12:00:35.593Z). This page did not run LatentSync and does not mark a row as enough. Which listing you can start is on https://cloudgpu.app/deploy.
Which commands run inference, and where is the video written?
The README install is source setup_env.sh. The README does not print a git clone. This page adds git clone https://github.com/bytedance/LatentSync.git and cd LatentSync before that script. The script creates a conda environment named latentsync with Python 3.10.13, installs requirements.txt, and downloads ByteDance/LatentSync-1.6 whisper/tiny.pt and latentsync_unet.pt into checkpoints. The README command is ./inference.sh. The script runs python -m scripts.inference with --video_out_path video_out.mp4, --inference_steps 20, and --guidance_scale 1.5. video_out.mp4 is a relative path. The Gradio command is python gradio_app.py. process_video writes ./temp/{video stem}_{YYYYMMDD_HHMMSS}.mp4. This page did not run the commands.
How do I open the Gradio app, and does the documentation document ComfyUI?
The README command is python gradio_app.py. gradio_app.py calls demo.launch(inbrowser=True, share=True) and does not pass server_name or server_port. This page does not state a port number. The app slider for inference steps starts at 10. The README inference_steps range starts at 20. The README does not document ComfyUI. The ComfyUI examples top-level directory list on 2026-11-13 had no directory named for this project. Examples HEAD was f9431bb000ce792094ff345446e22cac1ea6cef3.
Which license covers LatentSync?
The repository LICENSE file is the Apache License, Version 2.0. The appendix copyright line is the unfilled template Copyright [yyyy] [name of copyright owner]. The GitHub license field on 2026-11-13 was Apache-2.0. The ByteDance/LatentSync-1.6 model card had cardData.license openrail++, top-level license null, and gated false. This page does not paste the OpenRAIL++ clauses. Read the repository file and the card before you redistribute the program or the weights.
Sources (read 2026-11-13, Asia/Shanghai)
- LatentSync README (8 GB and 18 GB inference lines, the training GB lines,
source setup_env.sh,./inference.sh,python gradio_app.py): https://github.com/bytedance/LatentSync/blob/main/README.md commita229c3948406bc2cf6eaf4873e662e70c6a04746. Repository HEAD is that commit, committed 2025-06-20T07:36:51Z setup_env.sh(conda Python 3.10.13,huggingface-cli download ByteDance/LatentSync-1.6): commitd058a6146983053d07239440fc62be16102d1e86requirements.txt(torch==2.5.1,cu121index,gradio==5.24.0): commit404e34d4ac66a64851dac23f301b20bee0b3cda9inference.shandscripts/inference.py(video_out.mp4,stage2_512.yaml): commit19d6ae6bfb9ceff8146b01a592cdd08e1e76394econfigs/unet/stage2_512.yaml(resolution: 512) andconfigs/unet/stage2.yaml(resolution: 256): commit19d6ae6bfb9ceff8146b01a592cdd08e1e76394egradio_app.py(demo.launch(inbrowser=True, share=True),./temp/{stem}_{timestamp}.mp4): commit43d562e2dc6a03a2564ebc299e36a0845e676691LICENSE(Apache 2.0, unfilled copyright template): commit30251f02f1c5ba94e23b0ea510222b7bd29d4a25. GitHub license field Apache-2.0- Model card
ByteDance/LatentSync-1.6(openrail++,gatedfalse, no GPU GB figure in the card README this page read), read 2026-11-13 - ComfyUI examples top-level directories (no LatentSync directory): https://github.com/comfyanonymous/ComfyUI_examples commit
f9431bb000ce792094ff345446e22cac1ea6cef3 - Public GPU memory: https://cloudgpu.app/gpu-prices.json (
updated_at2026-11-13T12:00:35.593Z) and https://cloudgpu.app/v1/public/gpu-catalog (generated_at2026-11-13T12:00:36.648Z).GET /v1/public/compute-capabilitiesreturned feature flags and no GPU list. The catalog had no LatentSync template
Cards you can start are on the Deploy page. Prices are on https://cloudgpu.app/pricing and are not repeated here.
Last updated: 2026-11-13 (Asia/Shanghai).