LTX Desktop

LTX Desktop is an open-source, AI-powered video production suite (currently in beta) that runs on your own machine. It combines a full non-linear editor with on-device AI generation — text-to-video, image-to-video, audio-to-video, retake, extend, image generation and editing, LoRA support, and timeline import/export with professional NLEs.

Local generation runs on Windows and Linux machines with an NVIDIA GPU (16GB+ VRAM) and on Apple Silicon Macs. On unsupported hardware the app falls back to API mode, using the same interface with cloud compute. Local generation defaults to LTX-2.5 Fast; LTX-2.3 Fast is also available in Settings.

Once your model weights are downloaded, local generation works offline.

Yes. LTX Desktop is free and open source under Apache 2.0, and if your machine can run LTX-2.5 locally there are zero inference costs — no per-generation fees. The app is our way of showing what's possible with LTX-2.5 and giving the community something to build on.

If you don't meet the hardware requirements for local inference, or you prefer cloud compute, you can enable LTX API inference in Settings. API video generation is paid; API text encoding is free.

‍Note: the underlying model weights are governed separately by the LTX-2.x Community License Agreement — free for commercial use by companies under $10M in annual revenue; above that threshold a commercial licence applies. Other bundled models (Gemma 3 / Gemma 4, Z-Image Turbo and others) have their own terms, listed in NOTICES.md.

Gen Space — AI generation

• Text-to-video and image-to-video generation
• Still image generation (via Z-Image Turbo)
• Audio-to-Video
• Retake - regenerate specific portions of an input video

Full non-linear editor

Professional Editing Tools

• Trim tools - slip, slide, roll, and ripple
• Built-in transitions
• Primary color correction tools

AI-Native Editing

• Generate multiple takes per clip directly in the timeline and switch between them non-destructively. Each new version is nested within the clip, keeping your timeline modular.
• Context-aware gap fill - automatically generate content that matches surrounding clips
• Retake - regenerate specific sections of a clip without leaving the timeline

Interoperability

• Import/Export XML timelines for round-trip edits back to other NLEs
• Supports timelines from Premiere Pro, DaVinci Resolve, and Final Cut Pro

Integrated Text & Subtitle Workflow

• Text overlays directly in the timeline
• Built-in subtitle editor
• SRT import and export

High-Quality Export

• Export to H.264 and ProRes

Editor-Friendly Experience

• Fully customizable keyboard shortcuts
• Keyboard preset layouts for Premiere, DaVinci Resolve, and Avid

Disk space covers model weights, the Python environment and your outputs. You can start generating video with far less — see “What models does it download?” below.

Below these thresholds — no CUDA GPU, under 16GB VRAM, an Intel Mac, or a Mac with less than 15GB free RAM at launch — the app automatically switches to API mode, which only needs a stable internet connection.

AMD / Intel GPUs: Not currently supported for local generation. If this matters to you, add a 👍 to the tracking issue on GitHub.

Yes. LTX Desktop runs on Apple Silicon Macs (M1 and later) on macOS 13 or later, and generates locally on the GPU via MPS — no API key required.

Local generation needs at least 15GB of free RAM — free, not total. The app checks this once, at launch, and doesn't re-check while running. If a capable Mac lands in API-only mode, close memory-heavy apps (browsers are usually the culprit), then quit and relaunch — freeing memory while the app is already open has no effect until the next launch.

Intel Macs have no MPS backend and stay in API mode.

Option 1 — Installer (recommended): download the latest build from the GitHub Releases page:

• Windows: LTX-Desktop-Setup.exe
• macOS (Apple Silicon): LTX-Desktop-arm64.dmg (or the .zip)
• Linux: .deb or .AppImage, for x64 and arm64

The app auto-detects your hardware and walks you through downloading model weights on first launch. You may be asked to sign in to Hugging Face and accept the model licence, since the LTX-2.5 weights are gated.

Packaged installs check GitHub Releases for updates. Updates are opt-in: when a new version is found you can choose Update now, Later, or Skip this version — nothing downloads until you say so, and quitting never installs. Settings → About has a manual check and an auto-check toggle.

Option 2 — Run from source: you’ll need Node.js, uv, Python 3.12+ and Git, then pnpm setup:dev and pnpm dev. See the README and CONTRIBUTING.md.

LTX Desktop downloads models from Hugging Face on first launch. The download wizard shows the exact size of each file and lets you choose which you need. The LTX-2.5 weights are gated, so you'll be asked to sign in to Hugging Face and accept the licence first.

To start generating video locally you need the transformer, upscaler and VAEs — about 45GB — using the free LTX API for text encoding. Add the local text encoder (~26GB) to run fully offline. On Windows and Linux there's also a one-time Python environment download (~10GB) for local inference.

Only for setup. You'll need a connection to download the app, sign in to Hugging Face and download model weights on first launch.

After that, local generation runs entirely offline — your footage, prompts and generated content never leave your machine. A connection is still used for optional things: API-backed generation, free API text encoding (if you skip the local text encoder), the in-app LoRA library, Enhance via Gemini, and checking for app updates.

LTX Desktop also sends minimal anonymous analytics by default — app version, platform and a random installation ID, never personal information or generated content. You can turn it off in Settings → General → Anonymous Analytics.

The Gemini API key is optional. It's used for two things: the context-aware gap fill feature in the timeline editor, and “API” mode for the Enhance prompt button — the same prompt rewriting you get locally, without downloading the local text encoder.

You can pick which Gemini model to use next to your key in Settings → API Keys; the default is Gemini 3.5 Flash-Lite. Local Enhance runs on-device and needs no key.

The fal.ai API key is optional and intended for users who can't run Z-Image Turbo locally — it powers text-to-image generation and image editing in API mode. If your machine can run the model locally, you don't need it.

You can also opt into API-based image generation even on capable hardware, from Settings → General → Images Generation.

Yes. Local generation offers 540p, 720p and 1080p. 1080p uses the spatial upsampler (~1GB) from the model wizard to 2× upscale, so make sure it's downloaded. You'll want at least 12GB of VRAM to generate and upscale to 1080p locally.

Higher resolutions — 1440p and 2160p (4K) — are available through the LTX API rather than locally. Cloud-based upscaling of a locally generated clip isn't supported; the local upsampler is the path to 1080p on-device.

Yes, please do! Fork it, extend it, build your own tool on the same engine. LTX Desktop is Apache 2.0 and is a foundation for you to build on.

Submit and upvote feature ideas in GitHub Discussions → Ideas. The roadmap is community-driven.

One heads-up if you're planning a contribution: the app is in beta and the frontend is under active refactor, so large UI or state rewrites may be declined for now — open an issue first to align on direction. See CONTRIBUTING.md.

File a GitHub issue at github.com/Lightricks/LTX-Desktop/issues.

Before filing, open Help → View Logs in the app and download the log file — it includes your GPU, OS, app version and error details. Attaching it will help diagnose the problem much faster.

Join the #ltx-desktop channel on Discord. It's the main place for setup help, usage questions, and sharing what you've built. For deeper discussions and feature ideas, head to GitHub Discussions.

LTX Desktop runs on LTX-2.5, a 22B parameter multimodal model from Lightricks. Learn more on HuggingFace or read the technical paper.

Local generation uses the distilled LTX-2.5 Fast checkpoint by default. You can switch the active local model to LTX-2.3 Fast in Settings → Models — it's the one to use if you want Retake, Extend or the built-in IC-LoRAs on-device. Pro variants of both are available through the API.

For more technical detail, see the README.

It depends on how you generate, but you do need to set up text encoding one way or the other before you can generate video.

Running locally: a key is optional. You can either use free LTX API text encoding — recommended, since it speeds up inference and saves memory — or download the local text encoder (~26GB) and skip the key entirely.

Running in API mode: a key is required, and video generation is paid.

Generate a free key at the LTX Console. Text encoding is free; only API video generation and Retake are billed. Your key is stored locally in your app data folder — treat it like a secret.

Yes. Linux is supported for local generation on Ubuntu 22.04 or a similar distro (x64 or arm64), with an NVIDIA GPU with CUDA support and 16GB+ VRAM, and the NVIDIA driver installed — PyTorch bundles the CUDA runtime.

Download the .deb or .AppImage from the Releases page. Without a supported GPU, the app runs in API mode.

LTX Desktop keeps settings, models and logs in one app data folder:

• Windows: %LOCALAPPDATA%\LTXDesktop\
• macOS: ~/Library/Application Support/LTXDesktop/
• Linux: $XDG_DATA_HOME/LTXDesktop/ (default ~/.local/share/LTXDesktop/)

Model weights live in the models/ subfolder — that's the one that gets large. You can choose a different location during setup. Custom LoRA .safetensors files go in models/loras/; files elsewhere may not be detected.