license: other
license_name: ltx-2.x-community-license-agreement
license_link: https://huggingface.co/Harsha001/LTX-2.5-22B-dev-uncensored-ROCmFPX/blob/main/LICENSE.txt
base_model: Lightricks/LTX-2.5
base_model_relation: quantized
pipeline_tag: text-to-video
library_name: gguf
tags: [gguf, rocmfpx, rocmfp4, amd, rocm, ltx-video, ltx-2.5, stable-diffusion.cpp, quantized, uncensored, heretic, abliterated]
extra_gated_prompt: >-
These files are Derivatives of LTX-2.x and are subject to the LTX-2.x Community License Agreement
(LICENSE.txt), including Section 4 and Attachment A (use restrictions and acceptable use policy).
Commercial Entities (annual revenues of at least USD 10,000,000) must obtain a paid license from
Lightricks ([email protected]) before any use other than a Non-Commercial Purpose (Section 2.2).
extra_gated_fields:
I have read the LTX 2 Community License Agreement in LICENSE and accept its terms: checkbox
I am not a Commercial Entity, or I hold a paid license from Lightricks, or my use is solely for a Non-Commercial Purpose: checkbox

LTX-2.5 22B dev, uncensored text encoder — ROCmFPX GGUF

Lightricks/LTX-2.5 dev for
stable-diffusion.cpp, with its Gemma 4 12B text encoder
de-censored by the Heretic refusal edit. The video transformer is in
Q4_0_ROCMFP4, the 4-bit ROCmFPX format for AMD GPUs; the text encoder
is in a ROCmFPX format. Everything needed besides the VAE is here.
Without the edit: Harsha001/LTX-2.5-22B-dev-ROCmFPX.

The diffusion file needs stable-diffusion.cpp built against the ROCmFPX fork of ggml. Stock sd.cpp, ComfyUI-GGUF
and other runners do not know its type. The patch is in this repo (sdcpp-rocmfpx.patch).

Not an official release of Lightricks, Google or the Heretic authors. Use is subject to the LTX-2.x Community
License Agreement (LICENSE.txt, NOTICE.md), including its use restrictions (Attachment A); "uncensored" does not
change them. Commercial Entities with annual revenues of at least USD 10 million need a paid license from
Lightricks for commercial use.

What "uncensored" means here

LTX-2.5 reads prompts through Gemma 4 12B. Gemma's refusal behaviour can weaken or partly ignore prompts it would
refuse in a chat. llmfan46/gemma-4-12B-it-uncensored-heretic
removes that behaviour (6 of 100 refusals instead of 99, KL divergence 0.12) by editing only the attention output
projections of layers 24-39.

• What it does: the text encoder no longer steers away from prompts Gemma would refuse.
• What it does not do: the video model is unchanged. It cannot generate anything it did not learn in training;
  no NSFW LoRA or fine-tune is merged.
• Why it is built this way: Lightricks ships its own tuned copy of Gemma: many of its tensors differ from
  Google's release (the projections edited here by 3-11 %). Dropping in the whole
  Heretic model, as other uncensored LTX encoders do, would throw that tuning away. Here only the Heretic change
  (heretic minus Google's original) is added to Lightricks' weights, in FP32, for the 16 edited tensors
  (relative size of the change 1.4-7.0 %); every other tensor, including the LTX
  video and audio projections, is Lightricks' own, bit for bit.
  The script is build/build_uncensored_te.py, its per-tensor numbers build/te_delta_stats.json.

Measured quality

4 prompts, 768×448, 33 frames, Euler, 20 steps, CFG 3.0, the negative prompt below, same seed per prompt. Every frame is compared with the frame of the same prompt, seed and index from the reference (132 frames per row). PSNR (dB) and SSIM: higher is closer. LPIPS: lower is closer (perceptual distance). Diffusion amplifies small weight changes over the steps, so a quantized model can give a different take of the same prompt (pose, composition) without any loss of quality.

On ordinary prompts the edit moves the videos a little more than the floor of the test (see the LPIPS column): mostly a different take of the same prompt. The test prompts are ordinary scenes; the difference on prompts that the stock encoder would weaken was
not measured. Most of the distance in the package rows comes from the 4-bit video transformer.

Every encoder quant that was measured, with the BF16 DiT, against the BF16 uncensored encoder:

Why the encoder is not 4-bit: Q4_0_ROCMFP4 moved the videos far more (LPIPS 0.27) than Q8_0_ROCMFPX (LPIPS 0.04). A text encoder's errors pass through all 48 Gemma layers and then condition every denoising step, so it is far more sensitive than the video transformer.

Norm weights stay in BF16. stable-diffusion.cpp's converter quantizes every tensor whose length fits the
block size, including the 1-D RMSNorm weights. Those hold outliers (in LTX-2.5's attention q/k norms one value per
32-value block can be 67 times the block median; in the Gemma encoder's layer norms values reach 600 next to a median
of 7), so in 4- or 8-bit blocks most of their values are lost. All files here keep them in BF16 with
--tensor-type-rules 'norm\.weight=bf16' (a few MB).

Files

How this was made

1. stable-diffusion.cpp (b13a482) built on the ROCmFPX ggml (fb08d7c) with sdcpp-rocmfpx.patch.
2. Importance matrix from the BF16 dev model over 6 calibration prompts (different from the test prompts), same settings.
3. sd-cli -M convert --type q4_0_rocmfp4 --tensor-type-rules 'keyframes_abs_pos_embedding=f32,norm\.weight=bf16' --imat-in imatrix.dat
   (the norm rule: see the note on norm weights).
4. Quality measured on GPU with every quantized weight expanded back to full precision and rendered with stock sd.cpp,
   so the numbers measure the stored weights. The fork's own GPU kernels for these types were not used (they are
   wrong on NVIDIA). AMD GPU kernels compute the same math in a different order, so results on an AMD GPU can differ
   slightly. These files have not been tested on AMD hardware yet.
5. Text encoder: build/build_uncensored_te.py (Lightricks gemma4-12b-with-proj-ltx-2.5-bf16, Heretic
   cf3bb4a, Google 707f0a3), then sd-cli -M convert --type q8_0_rocmfpx --tensor-type-rules 'norm\.weight=bf16'.

Run

git clone https://github.com/charlie12345/ROCmFPX
git clone https://github.com/leejet/stable-diffusion.cpp sdcpp && cd sdcpp && git checkout b13a482
git submodule update --init --recursive && git apply ../sdcpp-rocmfpx.patch
cmake -B build -DSD_USE_UPSTREAM_GGML=ON -DSD_GGML_SOURCE_DIR=$PWD/../ROCmFPX/ggml -DSD_ROCMFPX=ON -DSD_VULKAN=ON
cmake --build build -j
build/bin/sd-cli -M vid_gen --diffusion-model LTX-2.5-22B-dev-Q4_0_ROCMFP4.gguf --llm gemma4-12b-heretic-with-proj-ltx-2.5-Q8_0_ROCMFPX.gguf \
  --vae ltx-2.5-video-vae-conv-bf16.safetensors \
  --flash-attn off --cfg-scale 3.0 --steps 20 --sampling-method euler -n "worst quality, low quality, blurry, distorted, artifacts" \
  -W 768 -H 448 --video-frames 33 --fps 24 -p "a red fox running through fresh snow" -o fox.webm

--flash-attn off: on NVIDIA, sd.cpp's flash attention turned every latent into NaN (white frames) with LTX-2.5;
it has not been checked on AMD. The default diffusion VAE decoder is not supported by sd.cpp; use the conv one
from Lightricks/LTX-2.5 (vae/).