GitHub - deepbeepmeep/LTX-Desktop-WanGP: LTX-Desktop powered By WanGP itself powered among other things by LTX-2 Engine

LTX Desktop is an open-source desktop app for generating videos with LTX models — locally on supported Windows NVIDIA GPUs, with an API mode for unsupported hardware and macOS.

Status: Beta. Expect breaking changes. Frontend architecture is under active refactor; large UI PRs may be declined for now (see CONTRIBUTING.md).

This LTX Desktop fork powered by WanGP reduces the VRAM requirements from 32 GB to 6 GB.

check WanGP repo for more information (doc, discord, ...): https://github.com/deepbeepmeep/Wan2GP

Windows WanGP Quick Start

Use one of these two setup paths for local WanGP-backed generation on Windows:

Before running any pnpm command, make sure pnpm is installed and available in PATH.

Prerequisites:

• Node.js 18+ from https://nodejs.org/
• pnpm, usually enabled with Corepack:

corepack enable
corepack prepare pnpm@latest --activate
pnpm -v

If corepack is unavailable but Node.js is already installed, you can install pnpm with:

npm install -g pnpm
pnpm -v

1. Wan2GP not installed yet

pnpm setup:dev:win clones Wan2GP/ into this repository, installs the backend dependencies, and prepares a plug-and-play local setup.

pnpm setup:dev:win
pnpm dev

The desktop backend will prefer the repo-local checkout at .\Wan2GP.

2. Wan2GP already installed elsewhere

If you already have a working Wan2GP checkout and want LTX Desktop to reuse it, do not keep a local .\Wan2GP subfolder in this repo.

WANGP_ROOT is an environment variable that must point to the root folder of your existing Wan2GP checkout, meaning the folder that contains wgp.py.

Examples:

• Windows cmd.exe:

• Windows PowerShell:

$env:WANGP_ROOT = "D:\Wan2GP"

Set WANGP_ROOT before running setup. pnpm setup:dev:win will then reuse that checkout and install its requirements.txt into the LTX Desktop backend venv.

set WANGP_ROOT=D:\Wan2GP
pnpm setup:dev:win
pnpm dev

If you prefer the manual path instead of pnpm setup:dev:win, install the external Wan2GP requirements into the backend venv yourself after uv sync:

set WANGP_ROOT=D:\Wan2GP
pnpm install
cd backend
uv sync --extra dev
uv pip install --python .venv\Scripts\python.exe -r %WANGP_ROOT%\requirements.txt
cd ..
pnpm dev

The backend still runs in LTX Desktop's own backend/.venv unless you explicitly override it with LTX_BACKEND_PYTHON.

If both are present, LTX Desktop uses the local .\Wan2GP checkout first and falls back to WANGP_ROOT only when no local subfolder is available.

If you want WANGP_ROOT to persist across new Windows terminals, you can set it permanently with:

• cmd.exe:

setx WANGP_ROOT D:\Wan2GP

• PowerShell:

[Environment]::SetEnvironmentVariable("WANGP_ROOT", "D:\Wan2GP", "User")

Features

• Text-to-video generation
• Image-to-video generation
• Audio-to-video generation
• Video edit generation (Retake)
• Video Editor Interface
• Video Editing Projects

Local vs API mode

In API-only mode, available resolutions/durations may be limited to what the API supports.

System requirements

Windows (local generation)

• Windows 10/11 (x64)
• NVIDIA GPU with CUDA support and ≥32GB VRAM As low 6GB VRAM with WanGP
• 16GB+ RAM (32GB recommended)
• Plenty of free disk space for model weights and outputs

macOS (API-only)

• Apple Silicon (arm64)
• macOS 13+ (Ventura)
• Stable internet connection

Install

1. Download the latest installer from GitHub Releases: Releases
2. Install and launch LTX Desktop
3. Complete first-run setup

First run & data locations

LTX Desktop stores app data (settings, models, logs) in:

• Windows: %LOCALAPPDATA%\LTXDesktop\
• macOS: ~/Library/Application Support/LTXDesktop/

Model weights are downloaded into the models/ subfolder (this can be large and may take time).

On first launch you may be prompted to review/accept model license terms (license text is fetched from Hugging Face; requires internet).

Text encoding: to generate videos you must configure text encoding:

• LTX API key (cloud text encoding) — text encoding via the API is completely FREE and highly recommended to speed up inference and save memory. Generate a free API key at the LTX Console. Read more.
• Local Text Encoder (extra download; enables fully-local operation on supported Windows hardware) — if you don't wish to generate an API key, you can encode text locally via the settings menu.

API keys, cost, and privacy

LTX API key

The LTX API is used for:

• Cloud text encoding and prompt enhancement — FREE; text encoding is highly recommended to speed up inference and save memory
• API-based video generations (required on macOS and on unsupported Windows hardware) — paid
• Retake — paid

An LTX API key is required in API-only mode, but optional on Windows local mode if you enable the Local Text Encoder.

Generate a FREE API key at the LTX Console. Text encoding is free; video generation API usage is paid. Read more.

When you use API-backed features, prompts and media inputs are sent to the API service. Your API key is stored locally in your app data folder — treat it like a secret.

fal API key (optional)

Used for Z Image Turbo text-to-image generation in API mode. When enabled, image generation requests are sent to fal.ai.

Create an API key in the fal dashboard.

Gemini API key (optional)

Used for AI prompt suggestions. When enabled, prompt context and frames may be sent to Google Gemini.

Architecture

LTX Desktop is split into three main layers:

• Renderer (frontend/): TypeScript + React UI.
  • Calls the local backend over HTTP at http://localhost:8000.
  • Talks to Electron via the preload bridge (window.electronAPI).
• Electron (electron/): TypeScript main process + preload.
  • Owns app lifecycle and OS integration (file dialogs, native export via ffmpeg, starting/managing the Python backend).
  • Security: renderer is sandboxed (contextIsolation: true, nodeIntegration: false).
• Backend (backend/): Python + FastAPI local server.
  • Orchestrates generation, model downloads, and GPU execution.
  • Calls external APIs only when API-backed features are used.

graph TD
  UI["Renderer (React + TS)"] -->|HTTP: localhost:8000| BE["Backend (FastAPI + Python)"]
  UI -->|IPC via preload: window.electronAPI| EL["Electron main (TS)"]
  EL --> OS["OS integration (files, dialogs, ffmpeg, process mgmt)"]
  BE --> GPU["Local models + GPU (when supported)"]
  BE --> EXT["External APIs (only for API-backed features)"]
  EL --> DATA["App data folder (settings/models/logs)"]
  BE --> DATA

Development (quickstart)

Prereqs:

• Node.js
• uv (Python package manager)
• Python 3.12+
• Git

Setup:

# macOS
pnpm setup:dev:mac

# Windows
pnpm setup:dev:win

On Windows, pnpm setup:dev:win installs Wan2GP Python dependencies into the backend venv used by LTX Desktop. By default it clones https://github.com/deepbeepmeep/Wan2GP into the repo subfolder Wan2GP/, but if no local subfolder exists and WANGP_ROOT points to an existing checkout, it reuses that checkout instead. A repo-local Wan2GP/ remains directly usable on its own if you want to run Wan2GP from the subfolder.

Run:

Debug:

dev:debug starts Electron with inspector enabled and starts the Python backend with debugpy.

Typecheck:

Backend tests:

Building installers:

• See INSTALLER.md

Telemetry

LTX Desktop collects minimal, anonymous usage analytics (app version, platform, and a random installation ID) to help prioritize development. No personal information or generated content is collected. Analytics is enabled by default and can be disabled in Settings > General > Anonymous Analytics. See TELEMETRY.md for details.

Docs

• INSTALLER.md — building installers
• TELEMETRY.md — telemetry and privacy
• backend/architecture.md — backend architecture
• backend/WANGP_BACKEND.md — WanGP bridge configuration

Contributing

See CONTRIBUTING.md.

License

Apache-2.0 — see LICENSE.txt.

Third-party notices (including model licenses/terms): NOTICES.md.

Model weights are downloaded separately and may be governed by additional licenses/terms.