Sulphur-2-distilled-Q4_K_M-GGUF

Sulphur 2 distilled — GGUF Q4_K_M for ComfyUI

GGUF Q4_K_M conversion of the distilled diffusion transformer from SulphurAI/Sulphur-2-base, packaged with the BF16 text/audio auxiliary components, the full LTX video VAE, and a validated ComfyUI API workflow.

This package is designed for older NVIDIA GPUs without native NVFP4 tensor cores. On a modified RTX 2080 Ti 22 GB, it was 2.68× faster and used 3.65 GiB less peak VRAM than the existing Sulphur NVFP4 checkpoint in the same controlled workflow.

This is a modified quantized redistribution, not an official SulphurAI or Lightricks release.

Files

GGUF tensor layout: 2,672 F32, 28 BF16, 1,376 Q4_K, and 368 Q6_K tensors. The auxiliary checkpoint contains exactly 4 text-projection, 102 audio-VAE, and 1,227 vocoder tensors, all BF16.

The Gemma-3-12B text encoder is not included. Obtain gemma_3_12B_it_fp4_mixed.safetensors from the upstream LTX/Sulphur text-encoder distribution.

RTX 2080 Ti benchmark

Controlled workflow:

• 832×480
• 73 frames / 3.04 seconds at 24 fps
• 8 distilled steps, Euler, CFG 1.0
• full LTX video VAE
• joint video + audio sampling and AAC output
• same prompt and paired seeds
• reciprocal execution order
• one excluded prewarm per block
• 10 warm samples per format
• isolated ComfyUI GPU

Q4_K_M was 2.683× faster, reduced wall time by 62.7%, and saved 3,742 MiB / 3.65 GiB (17.2%) peak VRAM.

A separate isolated six-second sanity run (832×480, 145 frames, 8 steps, new seed) completed in 96.080 seconds warm and produced a 6.042-second H.264 video with 48 kHz stereo AAC audio. This is a single warm observation, not part of the N=10 benchmark above; the corresponding cold run took 278.714 seconds.

This result is hardware-specific. RTX 2080 Ti is Turing and has no native NVFP4 tensor-core path; the same ranking must not be assumed on Blackwell GPUs such as RTX 5090 or GB10.

Visual and media validation

All 24 benchmark jobs (20 measured + 4 prewarm) produced H.264 MP4s. The validated smoke output was 832×480 at 24 fps with 48 kHz stereo AAC audio.

Paired same-seed frames at 0.5, 1.5, and 2.5 seconds retained coherent subjects, clothing, walking motion, rainy-street reflections, and camera framing. No catastrophic Q4 regression was visible in this sanity check. This is not a formal perceptual-equivalence study; quantized formats can diverge compositionally even with the same seed.

Requirements

• Current ComfyUI with native LTX-2.3 AV nodes
• ComfyUI-GGUF
• Gemma-3-12B text encoder
• NVIDIA GPU with enough combined VRAM/offload capacity

The package was tested with ComfyUI 0.28.0, ComfyUI-GGUF commit 6ea2651, PyTorch 2.6.0+cu124, and --force-fp16 on RTX 2080 Ti.

Installation

Place the files as follows:

ComfyUI/models/diffusion_models/sulphur-distil-ltx23av-Q4_K_M.gguf
ComfyUI/models/checkpoints/sulphur-ltx23av-aux-bf16.safetensors
ComfyUI/models/vae/ltx_full_vae.safetensors
ComfyUI/models/text_encoders/split_files/text_encoders/gemma_3_12B_it_fp4_mixed.safetensors

Load sulphur_t2v_q4km_api.json through the ComfyUI API or use it as a reference when building a UI workflow.

The key graph split is:

• UnetLoaderGGUF loads the Q4_K_M diffusion transformer;
• LTXAVTextEncoderLoader loads Gemma plus sulphur-ltx23av-aux-bf16.safetensors;
• LTXVAudioVAELoader loads audio VAE/vocoder from the same auxiliary checkpoint;
• VAELoader loads ltx_full_vae.safetensors for video decode.

Distilled settings

• Steps: 8
• CFG: 1.0
• Sampler: Euler
• Scheduler: LTXVScheduler (max_shift 2.05, base_shift 0.95, terminal 0.1, stretch enabled)
• Tested resolution: 832×480 at 24 fps

Frame math:

• video frames: (N × 8) + 1
• audio latent frames: video_frames × 4 − 3
• 73 video frames → 289 audio frames → 3.04-second output at 24 fps

Honest caveats

1. The GGUF contains only the diffusion transformer. Keep the auxiliary checkpoint and full VAE installed; otherwise text projection, audio generation, or video decode will be missing.
2. The text encoder is still large. Q4_K_M makes the DiT fit comfortably, but Gemma-3-12B and decoder components still contribute to total VRAM/RAM use.
3. Exact quality equivalence is not claimed. The paired visual gate found no catastrophic regression, but broader prompts, image-to-video, faces, hands, text rendering, and long clips need wider evaluation.
4. Turing results do not predict Blackwell. NVFP4 can be preferable on hardware with native FP4 support.

Conversion notes

The original single-file BF16 checkpoint combines the diffusion transformer, text projection, video/audio VAEs, and vocoder. Only the 4,444-tensor diffusion transformer was converted to GGUF; non-DiT components were not blindly quantized.

The GGUF preserves the upstream config, model_version, and license metadata. scale_shift_table and audio/video learnable_registers remain F32 to preserve loader-visible shapes.

Credits

• Base model: SulphurAI/Sulphur-2-base
• Architecture and license: Lightricks LTX-2
• GGUF runtime: city96/ComfyUI-GGUF
• Quantization, auxiliary packaging, workflow, and RTX 2080 Ti validation: coolthor

License

Distributed under the LTX-2 Community License Agreement dated January 5, 2026, inherited from the upstream model. A complete copy is included as LICENSE and embedded in the GGUF/auxiliary metadata.

The files in this repository were modified through transformer extraction, quantization, and auxiliary-component repackaging. Downstream users must follow the complete Agreement and Attachment A, including its use restrictions and commercial-license threshold.

---

☕ If this saved you GPU hours, you can buy me a coffee.

---

Made by Thor Lin. Full benchmarks, setup notes and the runs that failed are on ai-muninn.com. More quantized models: huggingface.co/coolthor.

Provenance

This section documents release e9fbec9b86b677c7a72d75c8ffc1bb192095304c, inspected on 2026-11-14. Where the exact upstream commit used at build time is unknown, it is listed as not recorded rather than backfilled with today's upstream HEAD.

Source lineage

Build details

Tools and versions: ComfyUI-GGUF commit 6ea2651 with local LTX-2.3 AV detector/metadata/register patches; image quantizer built from llama.cpp tag b3962 plus lcpp.patch. Full commits and final patched source digest not recovered.

The 4,444-tensor diffusion transformer was extracted from the original 5,947-tensor BF16 checkpoint, preserving config/model_version/license metadata and keeping learnable_registers in F32. The transformer was quantized to Q4_K_M; the 1,333 BF16 text-projection/audio-VAE/vocoder auxiliary tensors were retained separately, and the full video VAE was packaged alongside them. The final DiT type counts in the recovered run were 2,672 F32, 28 BF16, 1,376 Q4_K and 368 Q6_K.

The existing records cover quantization and format conversion only; they don't mention any fine-tuning or merging by coolthor. That reflects the documentation, not an independent weight diff.

Exact build command: not recorded in the recovered material. The method description above is not a complete executable reproduction recipe.

Weight file SHA-256 checksums

The values below are Hugging Face LFS object SHA-256 values for the pinned release above. File sizes and digests agree with pinned tree metadata. They identify full file contents, not LFS pointer text or Git blob IDs. Calibration imatrices are included when present.

Verifying the files

Download the desired files from revision e9fbec9b86b677c7a72d75c8ffc1bb192095304c and compare sha256sum <file> (Linux) or shasum -a 256 <file> (macOS) with the table. If cloning with Git LFS, hash the downloaded weight files, not the LFS pointer files. A matching hash confirms your files match this release; it does not prove the weights came only from the listed base model with no other changes.

Checking how the weights were derived requires the exact upstream commit, tool versions, recipe and any calibration or training data, then re-running the build and diffing the weights with a format-aware tool (or comparing file hashes where serialization is deterministic). Because of the gaps listed below, this build can't be reproduced exactly today. Quantized files are expected to differ numerically from BF16 sources, and a raw file hash cannot establish a base-to-quant weight diff. No quantization rerun or weight-diff audit was performed for this provenance review.

Known gaps: Base revision; Full patched converter/quantizer commits or source digests; Exact extraction/conversion/quantization invocations.

Sources: existing model card and HF metadata.