# LTX Desktop: a local video generation app for NVIDIA and Apple Silicon machines

> LTX Desktop is an Electron and Python desktop application from Lightricks that runs LTX video models locally on supported GPUs, with an API fallback for everything else. The hardware gate is the whole story.

**Lightricks/LTX-Desktop** — An open-source desktop app for generating videos with LTX models

- Repository: https://github.com/Lightricks/LTX-Desktop
- Website: https://www.ltx.video
- Stars: 2,022 · Forks: 424
- Language: TypeScript
- License: Apache-2.0
- Published: 2026-09-10 · Updated: 2026-09-10 · Language: en
- Canonical page: https://hysenlabs.com/projects/lightricks-ltx-desktop

## What LTX Desktop is for, and who it excludes

The README describes LTX Desktop as an open-source desktop app for generating videos with LTX models, running locally on supported Windows and Linux NVIDIA GPUs or Apple Silicon Macs, with an API mode for unsupported hardware. That sentence is also the project's boundary. The app is a front end for a family of video models, and its main selling point is that inference happens on your own machine rather than in someone else's datacenter.

The feature list is broad: text-to-video, image-to-video, audio-to-video, text-to-image, image-to-image, a video edit mode called Retake, a video editor interface, and video editing projects. LoRA adapters are supported for local video generation. The repository topics include non-linear-editing, which lines up with the editor and project features rather than with generation alone. This is a tool for people who want to iterate on clips, not only produce one and stop.

The exclusion is explicit. Local generation needs a CUDA GPU with at least 16GB of VRAM on Windows or Linux, or an Apple Silicon Mac with at least 15GB of free RAM. Everything below those thresholds falls into API-only mode, which requires an LTX API key. Intel Macs have no MPS backend and are API-only by design. The README does not describe a CPU rendering path, so there is no slow fallback for someone with a mid-range laptop.

## How local and API modes split the work

The architecture is a packaged desktop shell around a Python backend. The repository carries electron/, frontend/, backend/, and shared/ directories, and package.json sets main to dist-electron/main.js with a Vite frontend. The backend is a separate Python process: the typecheck:py script runs pyright inside backend/ through uv, and an OpenAPI schema is exported from the backend and turned into TypeScript types for the frontend. That generated schema is checked in and verified in CI, which tells you the two halves talk over a defined HTTP contract rather than ad hoc IPC.

Model choice changes what you can do, not just how good the output is. LTX 2.5 Fast is the default local model and supports text-to-video, image-to-video, audio-to-video, IC-LoRA and user LoRAs, but the README states it has no local Retake or Extend. LTX 2.3 Fast is the one with the full local feature set, including Retake and Extend, and you switch to it in Settings > Models. LTX 2.5 Pro and 2.3 Pro are API-only. So a user who wants local editing features has to give up the newer default checkpoint to get them. That trade-off is easy to miss and worth reading twice.

Text encoding is a second fork. You can encode text through the LTX API with a free key, which the README recommends because it speeds up inference and saves memory, or you can download a local text encoder and stay fully offline. The free API key is a real dependency even in local mode unless you take the extra download.

## Installing LTX Desktop and running a first generation

There is no build step for normal users. The README points at GitHub Releases for the installer, and packaged installs check GitHub Releases for updates and apply them when you quit the app.

Download and install the current release, then launch the app.

```bash
# No package manager install. Get the installer from GitHub Releases.
# https://github.com/Lightricks/LTX-Desktop/releases
```

On first launch you may be prompted to sign in to Hugging Face and accept model license terms, because the 2.5 weights are gated. This needs internet. App data lands in a platform-specific folder, and model weights go into a models/ subfolder inside it.

```bash
# Windows
%LOCALAPPDATA%\LTXDesktop\

# macOS
~/Library/Application Support/LTXDesktop/

# Linux
$XDG_DATA_HOME/LTXDesktop/   # default: ~/.local/share/LTXDesktop/
```

Before generating anything, configure text encoding. The README gives two options and recommends the first: an LTX API key for cloud text encoding, which it says is completely free, or a local text encoder downloaded through the settings menu. The key comes from the LTX Console at console.ltx.video.

```bash
# In-app: Settings > Text Encoding
# Option A: paste an LTX API key from https://console.ltx.video/
# Option B: download the local text encoder (extra download, fully local)
```

To switch checkpoints, use Settings > Models. LTX 2.5 Fast is the default; LTX 2.3 Fast is the one to pick if you need local Retake or Extend. LoRAs are added through Browse LoRAs and Browse IC-LoRAs in local mode, which open a built-in library with previews and Hugging Face links, or you can drop your own .safetensors files in.

## The free RAM check is a one-shot launch gate

The macOS path has a failure mode worth understanding before you blame the app. LTX Desktop checks free RAM, not total RAM, and it does so only once, at launch, when the Python backend process starts. It is not re-checked while the app runs. If a browser or another memory-hungry process is holding memory at that moment, a capable Mac can land in API-only mode anyway.

The README gives the recovery step, and it is narrow: close the heavy apps, then quit and relaunch LTX Desktop. Freeing memory while the app is already open has no effect, because the check does not run again until the next launch. The stated floor is 15GB of free RAM, and the README notes that more headroom avoids weight streaming from disk, which is a performance consideration rather than a hard gate.

The same binary outcome applies on Windows and Linux, where the gate is VRAM instead. The README's table lumps together machines with no CUDA, less than 16GB of VRAM, and unknown VRAM, and sends all three to API-only mode. Unknown VRAM landing in API-only is the sharp edge: a machine that could have generated locally may be routed to the cloud because the app could not read the figure. The README does not document a manual override for that decision.

## LoRA support stops at the local boundary

LoRA adapters steer local video generation toward a style or subject, and they apply to text-to-video, image-to-video and audio-to-video on Windows and Linux NVIDIA hardware or Apple Silicon Macs. They do not apply in API or cloud mode. If your hardware puts you in API-only mode, the entire LoRA feature set is unavailable to you, including the built-in library. That is a larger functional gap than the hardware table alone suggests.

Compatibility is narrower than the family name implies. Local generation runs LTX 2.5 Fast or LTX 2.3 Fast, both described as 22B distilled models, and catalog entries list which models they support. LoRAs labeled LTX-2, LTX-2.3 or LTX-2.5 target this family and are supported. A LoRA built for a different base model is not covered by that statement.

The library also carries a trust boundary. Entries authored by LTX are official; everything else is community-contributed and flagged with a disclaimer that LTX does not endorse it or take responsibility for it. The README does not describe a review process for community entries, so the disclaimer is the control. Some gated models require a Hugging Face sign-in before download.

## LTX Desktop compared with ComfyUI

The obvious comparison is ComfyUI, and the difference is in who assembles the graph. ComfyUI is a node-based environment where you wire samplers, loaders and conditioning together yourself, which means you can build pipelines the original authors never imagined, at the cost of building them. LTX Desktop ships a fixed application: a Gen Space for generation, a video editor, and editing projects. The repository's package.json lists unit tests for keyframe controls, keyframe drop, keyframe strength and timeline gap fill, which points at a timeline-oriented editing surface rather than a node graph.

That makes LTX Desktop the faster route to a clip and the slower route to a custom pipeline. It also makes the model selection a settings toggle rather than a graph edit, which is convenient until you want a combination the settings do not expose. The 2.5 Fast versus 2.3 Fast split is exactly that kind of constraint: the app decides which features pair with which checkpoint, and you choose between them.

A second difference is the API fallback. ComfyUI assumes you have the hardware. LTX Desktop treats weak hardware as a supported configuration and routes it to cloud generation with an LTX API key, which is a genuine convenience for laptops and a real limitation for anyone who wanted local-only operation on that same laptop. The README notes that API-only mode may limit available resolutions and durations to what the API supports.

## Beta status, licence and the cost of keeping up

The README labels the project Beta and says to expect breaking changes. It also states that the frontend architecture is under active refactor and that large UI PRs may be declined for now, pointing at docs/CONTRIBUTING.md. For a user this matters less than for a contributor, but it does mean the interface can move between releases. The release cadence supports that reading: v1.2.5, v1.2.6 and v1.2.7 all landed within a week of each other in August 2026, and the last push to the repository was on 2026-08-26. Packaged installs update themselves on quit, so staying current is close to automatic, and the main upgrade cost is re-downloading model weights when the active checkpoint changes.

The disk budget is the real ongoing cost. The Windows requirements list 160GB or more of free space for model weights, the Python environment and outputs. Model weights download into the models/ subfolder and the README warns this can be large and take time. LoRA adapters add to that. On macOS the README only says plenty of free disk space, without a number.

The licence is Apache-2.0, and the repository includes LICENSE.txt and NOTICES.md. That covers the application code. The model weights are a separate matter: the README says newer weights, including 2.5, are gated on Hugging Face and that you must sign in and accept the license before downloading. The licence text is fetched from Hugging Face at first run. Nothing here is legal advice, but the practical point is that installing the app and accepting the model terms are two different acts, and the second one has its own terms you should read on the Hugging Face page.

## Conclusion

Adopt LTX Desktop if you have a CUDA GPU with at least 16GB of VRAM or an Apple Silicon Mac with at least 15GB of free RAM and you want generation to happen on your own machine. Skip it if your hardware falls below those floors and you object to holding an LTX API key, because the app does not offer a third path. Before installing, check free disk space against the 160GB figure the Windows requirements state, and confirm you can sign in to Hugging Face, since the 2.5 weights are gated and the app cannot download them without it.

## FAQ

### Is LTX Desktop free?

The application is open source under Apache-2.0. The README states that text encoding via the LTX API is completely free, and that LTX 2.5 Pro and 2.3 Pro are paid cloud generation.

### Can I run LTX locally?

Yes, if your hardware qualifies: a Windows or Linux machine with a CUDA GPU and at least 16GB of VRAM, or an Apple Silicon Mac with at least 15GB of free RAM. Everything else runs in API-only mode and needs an LTX API key.

### Can I use LTX on my Mac?

On Apple Silicon with macOS 13 or later and at least 15GB of free RAM, the app runs locally on MPS and downloads model weights. Intel Macs have no MPS backend and stay in API-only mode, which requires an LTX API key.

### How do I install LTX Desktop?

Download the latest installer from GitHub Releases, install and launch the app, then complete first-run setup. Packaged installs check GitHub Releases for updates and apply them when you quit the app.

### What is LTX Desktop?

It is an open-source desktop app for generating videos with LTX models, running locally on supported Windows and Linux NVIDIA GPUs or Apple Silicon Macs, with an API mode for unsupported hardware.

### How do I use LTX Desktop locally?

Install it on qualifying hardware, then in Settings > Models keep LTX 2.5 Fast or switch to LTX 2.3 Fast for the full local feature set including Retake and Extend. To avoid cloud text encoding entirely, download the local text encoder through the settings menu.

## Sources

- [License: Apache-2.0](https://github.com/Lightricks/LTX-Desktop/blob/main/LICENSE)
- [Lightricks/LTX-Desktop on GitHub](https://github.com/Lightricks/LTX-Desktop)
- [Project website](https://www.ltx.video)
- [README](https://github.com/Lightricks/LTX-Desktop/blob/main/README.md)
- [Releases](https://github.com/Lightricks/LTX-Desktop/releases)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/lightricks-ltx-desktop