LTX 2.3 System Requirements: VRAM and GPU Guide

"Can I run LTX 2.3 on my card?" is the single most searched question about this model, and it gets answered badly almost everywhere — usually with a confident VRAM number that nobody sourced.

Here is the honest situation: the LTX-2 Python package publishes no minimum VRAM table for inference. What it does publish is a precise set of memory-reduction switches, a checkpoint size, a training requirement, and hard constraints on resolution and frame counts.

There is exactly one place Lightricks names a consumer number, and almost nobody quotes it: LTX Desktop's hardware table, which requires ≥16 GB VRAM for local generation on Windows and Linux, and Apple Silicon with ≥15 GB free RAM on macOS. That is app-specific rather than a model spec — but it is an official figure, which beats every unsourced "12 GB minimum" you will read elsewhere.

This guide sticks to what is documented. Every requirement below comes from the LTX-2 official repository, its optimization docs, the Hugging Face model card, the LTX-Desktop repository, and the official ComfyUI tutorial, all checked in July 2026. Where a number is not published, this guide says so instead of guessing.

Start with the number that is published: 46.1 GB

The bf16 checkpoints — ltx-2.3-22b-dev.safetensors and ltx-2.3-22b-distilled-1.1.safetensors — are 46.1 GB each on Hugging Face. That is the weights alone, before activations, before the Gemma 3 12B text encoder, before latents.

That single fact frames everything else:

• Loading the full bf16 transformer entirely in VRAM is a datacenter-class proposition, not a consumer one.
• Every consumer setup is therefore some combination of quantization (shrink the weights) and offload (keep them somewhere other than VRAM).
• ComfyUI sidesteps this by shipping FP8 builds (ltx-2.3-22b-dev-fp8.safetensors), which is why the ComfyUI route feels lighter than the raw Python route.

Software requirements (documented)

From the LTX-2.3 model card and repository:

If you are on an older CUDA toolkit, that is the first thing to fix. Nothing else in this guide matters if the CUDA version is below the floor.

The memory levers, in the order you should pull them

These are the official flags. They are not community folklore — they come straight from the CLI reference.

1. FP8 quantization. Two policies exist:

The docs also tell you to set an allocator environment variable alongside it:

PYTORCH_CUDA_ALLOC_CONF=expandable_segments:True python -m ltx_pipelines.ti2vid_two_stages \
    --quantization fp8-cast --checkpoint-path=...

2. Offload. --offload {none,cpu,disk} moves transformer weights out of VRAM. cpu holds them in system RAM; disk streams them from disk when RAM is also tight, and the docs are explicit that this is slower. Default is none.

This is the flag that converts "won't fit" into "will run, eventually." If you offload to CPU, your system RAM becomes the real constraint — plan for RAM in the same ballpark as the checkpoint.

3. Batch size. --max-batch-size defaults to 1. Raising it reduces layer-streaming transfers but increases peak memory. On a tight card, leave it alone.

4. Fewer steps. The gradient-estimation denoising loop lets you run 20–30 steps instead of 40 while maintaining quality, per the optimization docs. Fewer steps is less time, not less memory — but on a slow offloaded setup, time is the thing that actually hurts.

5. Attention backend. On datacenter Blackwell (B200), the docs specify installing FlashAttention 4 at a pinned revision: uv pip install 'flash-attn-4==4.0.0b9'. On Hopper, the FlashAttention 3 wheel. On other CUDA GPUs, PyTorch SDPA is used automatically — you do not need to do anything.

Why nobody can give you one honest VRAM number

Peak memory for a video diffusion model is not a property of the model alone. It moves with:

• Resolution — and LTX 2.3 requires width and height divisible by 32
• Frame count — which must follow the 8k+1 convention (97, 193, and so on)
• Precision — bf16 vs FP8 changes the weight footprint outright
• Pipeline — one-stage vs two-stage; the two-stage path loads an upscaler and a distilled LoRA on top of the checkpoint
• Offload policy — which decides how much of the 46 GB is even resident

A "minimum VRAM" figure that ignores all five variables is decoration. The useful mental model is: decide your pipeline and precision first, then lower resolution and frame count until it fits.

That is also the practical debugging order when you hit an OOM. Drop frames before you drop resolution — frame count scales the token sequence hard, and the sequence length is what the attention layers actually pay for.

Skip the hardware question entirely? If your card is the bottleneck and you just need output, ltx23.app runs LTX 2.3 in the browser — same model family, no VRAM math, no CUDA version to chase. Useful for validating an idea before you decide whether a GPU upgrade is worth it.

Training is a different tier — and it is documented

Where inference has no published minimum, training does. The ltx-trainer documentation states that training requires an NVIDIA GPU with 80 GB+ VRAM for standard configurations, with a low-VRAM config for 32 GB GPUs using INT8 quantization.

That is a rare piece of hard guidance, and it is a useful calibration point: if full LoRA training on the 22B model wants 80 GB comfortably, you can infer that comfortable inference at high resolution in bf16 is not a 12 GB story either.

The one place Lightricks does publish a consumer threshold

The Python package declines to name a minimum, but a different official product does not: LTX Desktop, Lightricks' open-source desktop app, publishes an explicit hardware table for local generation.

Below those thresholds — or on an Intel Mac — the app falls back to an API mode instead of failing.

That 16 GB VRAM figure is the closest thing to an official consumer floor for running LTX 2.3 locally. It is app-specific rather than a model spec, but it is a published number from Lightricks, which puts it well ahead of anything you will find quoted elsewhere.

Mac and AMD

• Apple Silicon is officially supported — through LTX Desktop. The app runs local generation on MPS with ≥15 GB free RAM (not total), and the check runs once at launch. A Mac with a browser full of tabs can land in API-only mode; closing apps and relaunching is the fix.
• The Python package is CUDA-based. CUDA > 12.7 is a stated requirement, and the attention backends (FlashAttention 3/4, PyTorch SDPA) are described in CUDA terms. Its optimization documentation describes no ROCm or Apple Silicon path.
• AMD has no documented official path. People search ltx 2.3 amd and ltx 2.3 mlx in real volume, but that reflects demand, not support. Treat any AMD workflow you find as a community port and verify it yourself.

So the accurate summary is not "no Mac support" — it is Mac support lives in the app, not in the Python package.

A decision table you can actually use

FAQ

What are the official LTX 2.3 VRAM requirements? The Python package publishes no minimum-VRAM table for inference. What is published: 46.1 GB bf16 checkpoints, FP8 and offload flags to reduce footprint, an 80 GB+ requirement for standard training, and — via LTX Desktop — a ≥16 GB VRAM threshold for local generation in the app.

Does LTX 2.3 run on 12 GB or 16 GB? LTX Desktop's own threshold for local generation is 16 GB VRAM, so 16 GB is the documented consumer entry point. Below that, the official answer is the app's API mode or a browser route. With FP8 plus CPU offload at low resolution and frame count, smaller cards can participate in the Python/ComfyUI path — but treat any specific community claim as a report, not a spec.

Do I need custom ComfyUI nodes? No. ComfyUI's official documentation states the LTX-2.3 workflows are built in.

What resolutions are valid? Width and height must be divisible by 32; frame counts must follow the 8k+1 pattern. These are model constraints, not preferences.

Is FP8 or GGUF better for low VRAM? FP8 is the officially supported quantization path with two documented policies. GGUF builds are community work — popular, but not part of the official repository.

Bottom line

LTX 2.3's requirements are best understood as a budget you allocate, not a threshold you clear: 46 GB of weights, minus whatever FP8 saves, minus whatever you push to RAM or disk, against a resolution and frame count you control.

Set the pipeline and precision first, then shrink the output until it fits. And if the answer for your machine turns out to be "not comfortably," ltx23.app gets you the same model's output without the hardware conversation.

Sources

Verified July 2026 against primary documentation:

1. Lightricks/LTX-2.3 — Hugging Face model card — checkpoint sizes, Python/CUDA/PyTorch versions, resolution and frame constraints
2. Lightricks/LTX-2 — official GitHub repository — optimization tips, FlashAttention guidance
3. LTX-2 optimization documentation — FP8 policies, allocator env var, torch.compile, gradient estimation
4. LTX-2 installation & CLI flags — --offload, --quantization, --max-batch-size reference
5. LTX-2 available pipelines — one-stage vs two-stage component requirements
6. ltx-trainer documentation — 80 GB+ training requirement, 32 GB INT8 low-VRAM config
7. ComfyUI official LTX-2.3 tutorial — FP8 checkpoint builds, no custom nodes required
8. google/gemma-3-12b-it-qat-q4_0-unquantized — text encoder dependency
9. ComfyUI-LTXVideo integration repository — official ComfyUI integration
10. LTX-2 technical paper (arXiv 2601.03233) — architecture background
11. LTX-Desktop — hardware table with the ≥16 GB VRAM local-generation threshold, Apple Silicon MPS support, free-RAM check behavior

Where Lightricks publishes no figure — notably inference VRAM minimums for the Python package — this guide deliberately declines to supply one. The one official consumer number, ≥16 GB VRAM, comes from LTX Desktop's own requirements and is app-specific. Community-reported numbers vary too widely with resolution, frame count, and offload policy to state as requirements.