LTX-Desktop

LTX-Desktop is Lightricks’ open-source desktop application for generating and editing video with the LTX family of generative models. It packages a full local inference stack — model downloads, GPU execution, and a video editor — behind a polished Electron UI, so creators can run text-to-video, image-to-video, and audio-to-video generation without touching a Python environment or a Docker Compose file directly.

The app is hardware-aware by design: on launch, it checks available VRAM (Windows/Linux with an NVIDIA GPU) or free RAM (Apple Silicon) and automatically decides between local generation and an API-only fallback mode, so the same install works on a beefy workstation or a laptop with no discrete GPU. Local generation defaults to the distilled LTX 2.5 Fast checkpoint, with LTX 2.3 Fast and Pro-tier cloud models available as alternatives, and LoRA/IC-LoRA adapters let users steer style and subject without retraining anything.

Beyond generation, LTX-Desktop includes a genuine video editing surface — a timeline with gap-fill, keyframe controls, multi-keyframe blending, and native export via ffmpeg — plus a Retake feature for regenerating specific clips in place. The architecture cleanly separates a TypeScript/React renderer, a sandboxed Electron main process for OS integration, and a FastAPI/PyTorch backend that only reaches external APIs when a cloud-backed feature is explicitly used.

The project is Apache-2.0 licensed with no license-gated features in the codebase itself; the only paid component is optional use of Lightricks’ own LTX API for cloud text encoding, Pro-tier cloud generation, or Retake on unsupported hardware, all clearly disclosed in-app before any request leaves the machine.

What You Get

• A cross-platform Electron desktop app (Windows, Linux, macOS Apple Silicon) with automatic local-vs-API mode selection based on detected VRAM or free RAM
• Text-to-video, image-to-video, audio-to-video, and text-to-image/image-editing generation using the LTX 2.5 Fast (default), LTX 2.3 Fast, and API-only Pro models
• A built-in video editor with timeline gap-fill, keyframe strength controls, multi-keyframe blending, and Retake for regenerating individual clips
• A LoRA/IC-LoRA library browser for downloading community and official style/effect adapters, plus support for dropping in custom .safetensors files
• Catalog-aware prompt enhancement, either fully local or via the Gemini API, to rewrite prompts using model-specific vocabulary
• A FastAPI backend with an auto-generated, type-checked OpenAPI contract shared with the TypeScript frontend, so client and server stay in sync

Common Use Cases

• Generating short video clips from text or image prompts entirely on a local NVIDIA or Apple Silicon GPU, with no data leaving the machine
• Applying a custom LoRA to steer generated video toward a specific visual style or subject without retraining a model
• Assembling and gap-filling a rough video timeline from multiple AI-generated clips before exporting a finished cut
• Running on lower-spec hardware in API-only mode, using Lightricks’ free cloud text encoding and paid Pro generation instead of local inference
• Regenerating a specific segment of an existing video with Retake instead of re-running the whole generation

Under The Hood

Architecture LTX-Desktop is split into three cleanly separated layers rather than one monolithic Electron app. The renderer (frontend/) is a TypeScript/React tree of views (GenSpace, VideoEditor, Project) and panels that talks to the local backend purely over HTTP at localhost:8000 and to the OS only through a sandboxed preload bridge (window.electronAPI, with contextIsolation: true and nodeIntegration: false). The Electron main process (electron/main.ts, python-backend.ts, window.ts) owns app lifecycle, file dialogs, ffmpeg-based export, and spawning/monitoring the Python backend as a child process, including a ref-counted liveness monitor that suspends its own health-check kill switch during long GPU-bound generations so it doesn’t mistake a busy backend for a hung one. The backend (backend/) is a FastAPI app built through a create_app factory (app_factory.py) that is deliberately decoupled from runtime bootstrap side effects, injecting a handler and CORS origins rather than reading global state, with routers per feature (generation, retake, extend, ic_lora, lora_catalog) and a documented set of monkey-patches over the upstream ltx-core/ltx-pipelines packages isolated in services/patches/. Swapping the core inference layer would mean re-validating every one of those patches, which the codebase calls out explicitly in comments rather than leaving as tribal knowledge.

Tech Stack The frontend runs on Vite 7 with vite-plugin-electron, React 18, Zustand for state, Zod for schema validation, and Tailwind via PostCSS; electron-builder handles cross-platform packaging and electron-updater handles auto-updates. The backend is Python 3.12+ with FastAPI/Starlette/Uvicorn, managed by uv, and pulls in the actual generation stack — torch, torchvision, diffusers, transformers (pinned tightly to a Gemma-4-compatible range), peft for LoRA, and Lightricks’ own pinned ltx-core/ltx-pipelines packages, with platform-conditional extras like sageattention and natten on non-macOS and a macOS-specific torch<2.12 pin to keep torchaudio ABI-compatible on Apple Silicon. The two sides are contract-bound through an exported OpenAPI schema (openapi:export/openapi:types) compiled into TypeScript types the frontend imports directly, checked for drift in CI.

Code Quality Both halves of the app carry real automated test suites: backend/tests/ uses pytest against a TestClient-driven FastAPI app (auth, retake sampler selection, conditioning cache, VRAM checks, pyright itself is tested as a CI gate), and the frontend has targeted Node test-runner suites for keyframe math, timeline layout, and format helpers, run via pnpm scripts:test. The backend uses pyright in strict mode with additional unknown-type checks enabled, and CI runs both the pyright check and an OpenAPI contract diff check on every PR. Comments throughout the harder concurrency and hardware-detection code explain why, not just what — for example the generation-active suppression window and the free-RAM-at-launch caveat for the API-mode fallback — which suggests a codebase written with debugging pain already paid for once.

What Makes It Unique Most open-source AI video tools are either a bare inference script or a ComfyUI-style node graph aimed at power users. LTX-Desktop instead packages a specific model family into a consumer-grade desktop app with automatic hardware detection that transparently degrades from local GPU inference to a cloud API, rather than simply failing on unsupported machines. It also pairs generation with a genuine non-linear video editor (timeline, gap-fill, Retake-in-place) instead of treating the editor as an afterthought, and documents real-world GPU pitfalls (a dedicated mps-attention-memory-leak.md) alongside the code, reflecting lessons learned from shipping local diffusion inference on end-user hardware rather than a research demo.

Self-Hosting

Licensing Model Apache-2.0 licensed — the entire desktop app, editor, and local inference pipeline are open source with no license keys or feature gates in the codebase.

Self-Hosting Restrictions

• None imposed by the app itself; every feature that can run locally is available to every self-hosted install.
• Some capabilities are inherently cloud-only regardless of license: the LTX 2.5/2.3 Pro models and Retake on unsupported hardware require Lightricks’ paid API, since there is no local Pro checkpoint to run.

Enterprise Features None — there is no separate paid tier of the desktop app. The only recurring cost is usage of Lightricks’ own LTX API (video generation and Retake), which is billed per the LTX Console’s pricing, not the software license.

Cloud vs Self-Hosted Cloud (API) mode extends compatibility to hardware that can’t run local inference and unlocks Pro-tier models, at the cost of sending prompts and media to Lightricks’ API. Self-hosted/local mode keeps everything on-device but is capped at the Fast-tier checkpoints and requires a capable GPU or Apple Silicon Mac.

License Key Required No. An optional LTX API key is needed only for API-backed features (cloud text encoding, Pro generation, Retake); it is a usage credential, not a software license.