# Manual Installation

Relevant source files

The following files were used as context for generating this wiki page: - [.gitignore](.gitignore) - [README.md](README.md) - [models/instructions.txt](models/instructions.txt) - [modules/processors/frame/core.py](modules/processors/frame/core.py) - [modules/ui.json](modules/ui.json) - [requirements.txt](requirements.txt)

This document provides detailed instructions for manually installing Deep-Live-Cam from source code. Manual installation gives you greater control over the setup process and allows for platform-specific optimizations. This guide is intended for technical users comfortable with command-line operations. For information about using pre-built versions of Deep-Live-Cam, see [Pre-built Installation](#2.1). ## Prerequisites Before beginning the installation process, ensure your system meets the following requirements: | Requirement | Description | |-------------|-------------| | Python | Python 3.10 recommended (critical for macOS) | | pip | Python package manager | | git | Version control system | | ffmpeg | Media processing library | | Visual Studio 2022 Runtimes | Required for Windows users only | | Storage | At least 1GB of free disk space | Note: While Deep-Live-Cam can run on CPU-only systems, GPU acceleration is highly recommended for optimal performance. Sources: [README.md:112-116]() ## Installation Process The installation process follows a specific workflow to ensure all components are properly set up: ```mermaid flowchart TD A["Setup Platform
Python, pip, git, ffmpeg"] --> B["Clone Repository
git clone"] B --> C["Download Models
to 'models' directory"] C --> D["Install Dependencies
via requirements.txt"] D --> E["Run Deep-Live-Cam
python run.py"] subgraph "Optional GPU Setup" F["CUDA
(NVIDIA)"] G["CoreML
(Apple Silicon)"] H["DirectML
(Windows AMD)"] I["OpenVINO
(Intel)"] end E -.-> F E -.-> G E -.-> H E -.-> I ``` Sources: [README.md:100-176]() ### 1. Platform Setup First, ensure you have all prerequisite software installed on your system: - **Python**: Version 3.10 is recommended - **pip**: For package management - **git**: For cloning the repository - **ffmpeg**: For video processing - Windows: PowerShell command `iex (irm ffmpeg.tc.ht)` - macOS: `brew install ffmpeg` - Linux: `apt-get install ffmpeg` - **Visual Studio 2022 Runtimes**: Required for Windows users only Sources: [README.md:112-116]() ### 2. Clone the Repository Clone the Deep-Live-Cam repository from GitHub: ```bash git clone https://github.com/hacksider/Deep-Live-Cam.git cd Deep-Live-Cam ``` Sources: [README.md:120-123]() ### 3. Download Required Models Download the following model files and place them in the `models` directory: | Model | Description | Download URL | |-------|-------------|--------------| | GFPGANv1.4.pth | Face enhancement model | huggingface.co/hacksider/deep-live-cam/resolve/main/GFPGANv1.4.pth | | inswapper_128_fp16.onnx | Face swapping model | huggingface.co/hacksider/deep-live-cam/resolve/main/inswapper_128_fp16.onnx | Note: The models folder has an instructions.txt file with direct links to these models. Sources: [README.md:126-130](), [models/instructions.txt]() ### 4. Install Dependencies It's highly recommended to use a virtual environment to avoid conflicts with other Python packages. The installation process differs slightly depending on your operating system. ```mermaid flowchart TD A["Virtual Environment Setup"] --> B{"Operating System?"} B -->|"Windows"| C["venv\Scripts\activate"] B -->|"macOS/Linux"| D["source venv/bin/activate"] C --> E["pip install -r requirements.txt"] D --> E E --> F["Deep-Live-Cam Dependencies"] F --> G["Core Libraries"] F --> H["Vision Libraries"] F --> I["UI Libraries"] F --> J["Platform-specific
Libraries"] G --> G1["numpy, typing-extensions, psutil"] H --> H1["opencv-python, insightface, torch, torchvision"] I --> I1["tk, customtkinter, pillow"] J --> J1["onnxruntime variants"] ``` #### Windows ```bash python -m venv venv venv\Scripts\activate pip install -r requirements.txt ``` #### macOS (Apple Silicon - M1/M2/M3) ```bash # Install Python 3.10 (specific version is important) brew install python@3.10 # Install tkinter package (required for the GUI) brew install python-tk@3.10 # Create and activate virtual environment with Python 3.10 python3.10 -m venv venv source venv/bin/activate # Install dependencies pip install -r requirements.txt ``` #### Linux ```bash python -m venv venv source venv/bin/activate pip install -r requirements.txt ``` Important: The requirements.txt file automatically handles platform-specific dependencies. For macOS, it will install different packages than for Windows/Linux. Sources: [README.md:133-176](), [requirements.txt]() ### 5. Running Deep-Live-Cam After successful installation, you can run Deep-Live-Cam with: ```bash python run.py ``` Note that on first run, it may download additional models (~300MB). For macOS users with Apple Silicon, always use: ```bash python3.10 run.py ``` Sources: [README.md:176]() ## GPU Acceleration Setup Deep-Live-Cam supports various execution providers to leverage hardware acceleration. The setup varies depending on your hardware. ```mermaid flowchart LR A["run.py
Execution Provider Selection"] --> B{"Hardware Type"} B -->|"NVIDIA GPU"| C["CUDA
Execution Provider"] B -->|"Apple Silicon"| D["CoreML
Execution Provider"] B -->|"AMD GPU"| E["DirectML
Execution Provider"] B -->|"Intel CPU/GPU"| F["OpenVINO
Execution Provider"] C --> G["onnxruntime-gpu"] D --> H["onnxruntime-silicon"] E --> I["onnxruntime-directml"] F --> J["onnxruntime-openvino"] G --> K["modules.processors.
frame.face_swapper"] H --> K I --> K J --> K G --> L["modules.processors.
frame.face_enhancer"] H --> L I --> L J --> L ``` ### CUDA Execution Provider (NVIDIA) For NVIDIA GPU acceleration: 1. Install [CUDA Toolkit 11.8.0](https://developer.nvidia.com/cuda-11-8-0-download-archive) 2. Install the CUDA-specific dependencies: ```bash pip uninstall onnxruntime onnxruntime-gpu pip install onnxruntime-gpu==1.16.3 ``` 3. Run with CUDA execution provider: ```bash python run.py --execution-provider cuda ``` Sources: [README.md:180-194]() ### CoreML Execution Provider (Apple Silicon) For Apple Silicon (M1/M2/M3) acceleration: 1. Ensure you're using Python 3.10 (this is critical) 2. Install the CoreML-specific dependencies: ```bash pip uninstall onnxruntime onnxruntime-silicon pip install onnxruntime-silicon==1.13.1 ``` 3. Run with CoreML execution provider: ```bash python3.10 run.py --execution-provider coreml ``` Important notes for macOS users: - You **must** use Python 3.10, not newer versions - Always run with `python3.10` command - If you get an error about `_tkinter` missing, reinstall: `brew reinstall python-tk@3.10` Sources: [README.md:196-229]() ### DirectML Execution Provider (Windows) For AMD GPU acceleration on Windows: 1. Install the DirectML-specific dependencies: ```bash pip uninstall onnxruntime onnxruntime-directml pip install onnxruntime-directml==1.15.1 ``` 2. Run with DirectML execution provider: ```bash python run.py --execution-provider directml ``` Sources: [README.md:246-259]() ### OpenVINO Execution Provider (Intel) For Intel CPU/GPU acceleration: 1. Install the OpenVINO-specific dependencies: ```bash pip uninstall onnxruntime onnxruntime-openvino pip install onnxruntime-openvino==1.15.0 ``` 2. Run with OpenVINO execution provider: ```bash python run.py --execution-provider openvino ``` Sources: [README.md:261-274]() ## Understanding the Installation This section explains how the manual installation components integrate with the Deep-Live-Cam architecture. ```mermaid flowchart TD A["User Entry Point
run.py"] --> B["modules.core"] subgraph "Manually Installed Components" C1["GFPGANv1.4.pth
Face Enhancement Model"] C2["inswapper_128_fp16.onnx
Face Swapping Model"] C3["Python Libraries
From requirements.txt"] C4["Execution Providers
CUDA/CoreML/DirectML/OpenVINO"] end B --> D["modules.processors.frame.core"] D --> E["modules.processors.frame.face_swapper"] D --> F["modules.processors.frame.face_enhancer"] E --> G["modules.face_analyser"] F --> G C1 --> F C2 --> E C3 --> B C4 --> B B --> H["modules.globals"] H --> I["Execution Provider Configuration"] C4 --> I ``` When you run Deep-Live-Cam, the system loads the machine learning models and uses the appropriate execution provider specified during launch. The face swapper module uses the `inswapper_128_fp16.onnx` model, while the face enhancer uses the `GFPGANv1.4.pth` model. The processor modules are loaded dynamically based on the configuration specified in `modules.globals`. Sources: [modules/processors/frame/core.py](), [README.md]() ## Troubleshooting Here are solutions to common installation issues: | Issue | Solution | |-------|----------| | "ModuleNotFoundError" | Ensure virtual environment is activated and all dependencies are installed | | "No module named '_tkinter'" | Install tkinter: `brew install python-tk@3.10` (macOS) or `apt-get install python3-tk` (Linux) | | "CUDA not available" | Verify CUDA Toolkit installation and ensure compatible GPU | | Model loading errors | Check that models are in the correct location (models folder) | | "Failed to access CoreML device" | Ensure using Python 3.10 on macOS | | "Cannot allocate memory" | Use the `--max-memory` parameter to limit RAM usage | | Virtual environment issues | Delete and recreate the venv: `rm -rf venv` then repeat setup | In case of persistent issues, check for conflicting Python installations or incompatible package versions. Sources: [README.md:162-176](), [README.md:214-229]() ## Next Steps After successful installation, you may want to learn about: - [GPU Acceleration Setup](#2.3) for optimizing performance - [User Interface](#3.1) for understanding the application controls - [Image Processing](#3.2) and [Video Processing](#3.3) for basic usage