Deep Live Cam Tutorial 2026: Install, Requirements, and Fixes

Deep Live Cam is a project for creating real-time face swaps and one-click video deepfakes using a single image. This tutorial will guide you through the installation and basic usage, from the Windows quickstart to a manual install with GPU acceleration on NVIDIA, Apple Silicon, AMD and Intel hardware.

The official source is the Deep-Live-Cam repository on GitHub. Everything below follows the workflow that repository documents; if a step here and the README ever disagree, the README wins because the project moves quickly. If you are more interested in generating images than swapping faces, our Fooocus 2026 guide and our comparison of AI image generators are the better starting points.

Prerequisites

• Python (3.10 recommended)
• pip
• git
• FFmpeg
• Visual Studio 2022 runtimes (for Windows users)

Install Python, git and FFmpeg from their official sites. On Windows, tick "Add Python to PATH" during the Python install, and make sure ffmpeg -version works in a fresh terminal before you continue.

System Requirements

Deep Live Cam runs on any modern 64-bit machine, but live webcam mode is only comfortable with a discrete GPU. The table below summarises what each execution provider needs and what to expect from it.

Two practical notes. First, the webcam matters as much as the GPU: a 720p or 1080p camera with good lighting produces a much cleaner swap than a high-end GPU working from a dark, noisy feed. Second, the Python version is the single most common cause of a failed install, so create the environment with 3.10 even if your system default is newer.

Windows Quickstart vs Manual Install

The project offers a prebuilt Windows package as well as the manual git-based install; the quickstart is faster, the manual install is what you want for GPU tuning and updates.

Check the GitHub repository's README for the current quickstart download; the rest of this tutorial covers the manual route, which works everywhere.

Installation

Step 1: Clone the Repository

1. Open a terminal or command prompt.
2. Run the following command: git clone https://github.com/hacksider/Deep-Live-Cam.git
3. Navigate to the cloned directory: cd Deep-Live-Cam

Optional but recommended: create an isolated Python 3.10 environment before installing anything, so the pinned onnxruntime packages cannot collide with other projects:

python -m venv venv
# Windows
venv\Scripts\activate
# macOS / Linux
source venv/bin/activate

Step 2: Download Required Models

1. Visit the project's Hugging Face page.
2. Download the following models:
3. GFPGANv1.4
4. inswapper_128_fp16.onnx
5. Place these files in the models folder of the cloned repository.

The two files do different jobs: inswapper_128_fp16.onnx performs the actual face swap, and GFPGANv1.4.pth powers the Face Enhancer that restores detail afterwards. Both must sit directly inside models/, not in a subfolder.

Step 3: Install Dependencies

1. Install the required packages: pip install -r requirements.txt

Step 4: GPU Acceleration Setup (Optional)

Each execution provider needs its own onnxruntime package, and only one onnxruntime package can live in the environment at a time. Always uninstall the default before installing the accelerated build.

For NVIDIA GPUs:

1. Install CUDA Toolkit 11.8
2. Install additional dependencies: pip uninstall onnxruntime onnxruntime-gpu pip install onnxruntime-gpu==1.16.3

For Apple Silicon:

1. Install CoreML dependencies: pip uninstall onnxruntime onnxruntime-silicon pip install onnxruntime-silicon==1.13.1

For Windows DirectML:

1. Install DirectML dependencies: pip uninstall onnxruntime onnxruntime-directml pip install onnxruntime-directml==1.15.1

For Intel OpenVINO:

1. Install OpenVINO dependencies: pip uninstall onnxruntime onnxruntime-openvino pip install onnxruntime-openvino==1.15.0

Usage

Basic Usage

Run the application with:
python run.py

GPU-Accelerated Usage

For NVIDIA GPUs:

python run.py --execution-provider cuda

For Apple Silicon:

python run.py --execution-provider coreml

For Windows DirectML:

python run.py --execution-provider directml

For Intel OpenVINO:

python run.py --execution-provider openvino

If the flag is accepted but performance does not change, the matching onnxruntime package is not the one installed; see the troubleshooting table below.

Interface

1. Select a face image using the "Choose Face" button.
2. For live webcam mode:
   • Click "Live" to use your webcam feed.
3. For video processing:
   • Select a target video using the "Choose Target" button.
   • Click "Start" to begin processing.

Additional Options

• Face Enhancer: Improves output quality (may slow down processing)
• Many Faces: Processes every face in the frame
• Keep FPS: Maintains original video frame rate
• Keep Audio: Preserves original audio

Choosing a Good Source Image

The source image decides most of the result quality. Use a sharp, front-facing photo with even lighting, no sunglasses or heavy occlusion, and a neutral expression; the model maps that single face onto every frame, so anything odd in the source is repeated everywhere.

Command Line Arguments

For advanced usage, you can use the following command line arguments:

• -s, --source: Select source image
• -t, --target: Select target image or video
• -o, --output: Specify output file or directory
• --frame-processor: Choose frame processors
• --keep-fps: Keep original FPS
• --keep-audio: Keep original audio
• --many-faces: Process every face
• --video-encoder: Adjust output video encoder
• --video-quality: Adjust output video quality
• --max-memory: Set maximum RAM usage
• --execution-threads: Set number of execution threads

A typical headless run that swaps a face into a saved clip and keeps the original audio looks like this:

python run.py -s face.jpg -t input.mp4 -o output.mp4 --keep-fps --keep-audio --execution-provider cuda

Notes

• Processing speed depends on your hardware. GPU acceleration significantly improves performance.
• For live webcam mode, ensure your webcam is properly connected and recognized by your system.
• Always use this software responsibly and ethically.

Common Installation Errors and Fixes

Most failed installs come down to one of the problems in this table; the detailed fixes follow.

ModuleNotFoundError: No module named 'tkinter' — the GUI depends on Tk, which is not
bundled with every Python build. On Debian or Ubuntu install python3-tk. On macOS,
install Python from python.org rather than a bare Homebrew build, or add python-tk.

Both onnxruntime and onnxruntime-gpu installed — when both packages share an
environment the app silently falls back to CPU and you get a few frames per second with no
error message. Uninstall both, then reinstall only the one matching your hardware, exactly
as listed in Step 4.

Models not found at launch — GFPGANv1.4.pth and inswapper_128_fp16.onnx must sit
directly inside the models/ folder at the repository root. A nested folder will not be
picked up.

ffmpeg not found — video export fails without FFmpeg on your PATH, sometimes without
a clear message. Confirm with ffmpeg -version before you process any video.

CUDA version mismatch — the onnxruntime-gpu build has to match your installed CUDA
toolkit. If the app starts but ignores --execution-provider cuda, this is almost always
why. Either install the onnxruntime build matching your CUDA version, or install CUDA 11.8
to match the pinned version above.

Out of memory on longer videos — cap usage with --max-memory and reduce
--execution-threads. Splitting a long video into segments and rejoining them afterwards
is more reliable than forcing a single pass.

Webcam not detected — Live mode needs exclusive access to the camera. Close browser tabs and conferencing apps that hold it, and on macOS grant camera permission to the terminal application that launched Python. External USB cameras are sometimes enumerated as a second device, so try the other camera index if the project's settings expose one.

What Performance to Expect

Live webcam mode is far more demanding than processing a file, because every frame has to
be detected, swapped and enhanced inside one frame interval. A discrete NVIDIA GPU with
CUDA is the only configuration that holds a comfortable live frame rate; Apple Silicon via
CoreML is usable but slower; CPU-only is fine for processing a video file in the background
and not much else.

Two settings dominate speed. Face Enhancer noticeably improves output quality and
noticeably reduces frame rate — leave it off while you frame your shot, then enable it for
the final render. Many Faces multiplies work by the number of faces detected, so leave
it off unless you actually need every face in frame swapped.

Resolution is the third lever. Lowering the webcam capture resolution in your camera settings raises the frame rate on every provider, and the swap model works at a low internal resolution anyway, so the visual cost is small.

Legal and Ethical Use

Face-swap tools sit in a genuinely regulated area, and the rules tightened considerably
through 2025 and 2026. Several jurisdictions now treat non-consensual synthetic imagery of
a real person as a criminal matter, and platform policies are stricter than the law in most
cases.

The project itself sets the baseline: its README requires users to obtain consent from anyone whose face they use, asks that synthetic output be clearly labelled as a deepfake when shared, and includes a built-in check that blocks processing of nudity and other inappropriate content. Treat those as the minimum, not the whole answer.

The practical rule: obtain explicit consent from anyone whose likeness you use, disclose
synthetic media when you publish it, and never use it to impersonate someone for
verification, financial or reputational purposes. Check the rules where you live before you
publish — this guide covers how the software works, not whether your intended use is lawful.

Related Tools

Deep Live Cam swaps faces; if you need to alter a whole body or identity in a still image, our review of Live3D AI body swap covers a hosted alternative. For generating entirely new imagery rather than editing real footage, start with Fooocus or the tools in our AI image generator comparison.

FAQ

Does Deep Live Cam work without a GPU?

Yes, but slowly. CPU-only execution is workable for processing a saved video file and
impractical for live webcam use.

Which Python version should I use for Deep Live Cam?

Python 3.10 is the version the project targets and the one to use in 2026. Newer interpreters frequently break the pinned onnxruntime and dependency versions, so create a dedicated 3.10 virtual environment even if your system Python is newer.

Can I use it as a webcam in Zoom, OBS or Meet?

Not directly. Deep Live Cam renders to its own preview window. To feed another application
you need a virtual camera — capture the preview window in OBS and route it through OBS
Virtual Camera, then select that device inside your conferencing app.

Why does the swapped face look blurry or low-detail?

The base swap model works at a low internal resolution, which is what the Face Enhancer
option exists to correct. Enable it for final output. A higher-resolution, well-lit,
front-facing source image also makes a large difference.

Does one source image really need to be enough?

Yes — the model is designed around a single reference image. Quality depends far more on
that image being sharp, evenly lit and close to front-facing than on providing more images.

Which execution provider should I choose?

cuda for NVIDIA, coreml for Apple Silicon, directml for AMD or Intel GPUs on Windows,
and openvino for Intel hardware. Each requires its matching onnxruntime package.

Is the Windows quickstart package better than the manual install?

The quickstart is the faster way to try Deep Live Cam on Windows because Python, dependencies and GPU support come preconfigured. The manual install is better once you want to pick your execution provider, pass command line arguments, or pull updates with git.

Last reviewed and updated: September 2026.