coolthor/Sulphur-2-distilled-NVFP4

Sulphur 2 (distilled) — NVFP4

NVFP4 (TensorCore block-scaled FP4) weight-only quantization of the distilled Sulphur 2 model — an uncensored text-to-video + audio diffusion transformer built on LTX-2.3. The text encoder is Gemma-3-12B.

This is a single-file ComfyUI checkpoint (sulphur_distil_nvfp4.safetensors, ~19 GB) bundled with the standalone full LTX VAE and a validated t2v API workflow.

📝 Full write-up, benchmarks & the gotchas in detail: NVFP4 video on a DGX Spark — with zero speed gain (ai-muninn.com · DGX Spark Part 34)

What this is

• —Format: NVFP4 weight-only. The diffusion DiT weights are packed FP4 (4-bit) with per-block FP8 (E4M3) scale factors and per-tensor FP32 global scales — the standard NVFP4 layout. Norms, embeddings and a handful of sensitive layers stay BF16. (Header dtype profile: 1344 U8 packed-FP4 / 1344 F8_E4M3 block scales / 1344 F32 global scales / 4603 BF16.)
• —Base: `SulphurAI/Sulphur-2-base` (distilled variant), an uncensored model based on Lightricks LTX-2.3.
• —Size: ~19 GB, vs the FP8 distilled release (~28 GB). That is roughly a 32% cut over FP8. Fits comfortably on a 32 GB card (e.g. RTX 5090) with room for the VAE and text encoder.

Honest caveats (read these)

1. NVFP4 here is a SIZE play, not a speed play. Video diffusion is compute-bound, not bandwidth-bound. So NVFP4 does not make this faster than FP8 — on the hardware tested it runs no faster than FP8 (in fact a reproducible ~6%% slower — see the speed note below), it just takes ~32%% less disk and VRAM. The win is "fits a 32 GB GPU," not "generates faster." If you have the VRAM for FP8 and don't need the smaller footprint, NVFP4 buys you nothing on speed.

Generation speed (measured, GB10 DGX Spark): ~6 s of compute per 1 s of 832×480 video at 8 steps, warm — a 3 s clip is ~18-19 s (cache-busted N=3: FP8 18.0 s vs NVFP4 19.1 s; NVFP4 is ~6%% slower, never faster, since it is compute-bound). The first generation after a cold start takes ~2 min while kernels compile. To go faster you need more compute (an RTX 5090), not this big-memory box.

2. The embedded VAE HANGS — you MUST use the included standalone VAE. The VAE baked into this checkpoint dequantizes on CPU and hangs. Do not rely on the embedded VAE, and do not use the tiny tae preview VAE (it's blurry — Laplacian variance ~45 vs the full VAE's ~205). Load the included `ltx_full_vae.safetensors` (the extracted full LTX VAE, ~1.45 GB) via a VAELoader node. This is mandatory to get usable output. The provided workflow already wires this up (node 22 → VAEDecode).

3. ComfyUI launch flags are required or the sampler crashes. Launch ComfyUI with:

--disable-async-offload --disable-dynamic-vram

Without these, the sampler crashes with 'NoneType' object has no attribute 'wait_stream' in model_prefetch.py.

Files

The Gemma-3-12B text encoder (gemma_3_12B_it_fp4_mixed.safetensors) is not included — get it from the upstream Sulphur 2 / LTX-2 text-encoder distribution and place it at models/text_encoders/split_files/text_encoders/.

Usage (ComfyUI)

Distilled settings:

• —Steps: 8
• —CFG: 1.0
• —Sampler: euler, LTXVScheduler (max_shift 2.05, base_shift 0.95, terminal 0.1, stretch)
• —Resolution tested: 832 × 480 @ 24 fps

Frame math:

• —Video frame count: (N × 8) + 1 (the example uses 73 frames)
• —Audio latent frames: video_frames × 4 − 3 (73 → 289)

Place the files:

ComfyUI/models/diffusion_models/sulphur/sulphur_distil_nvfp4.safetensors
ComfyUI/models/vae/ltx_full_vae.safetensors

Load sulphur_t2v_nvfp4_api.json as an API-format workflow. It produces video + synced audio in one pass (LTXVConcatAVLatent → sample → LTXVSeparateAVLatent → audio VAE decode → CreateVideo with audio).

Validation

Produced a sharp 832 × 480, 24 fps clip with synced AAC audio on a GB10 DGX Spark. Sharpness measured at Laplacian variance 205.79 with the full VAE (the tiny tae VAE comes in around ~45 on the same content — visibly blurry, hence the "use the full VAE" requirement above).

Credits

• —Base model: `SulphurAI/Sulphur-2-base` — uncensored Sulphur 2, distilled variant.
• —Upstream architecture: Lightricks LTX-2 / LTX-Video (LTX-2.3).
• —Text encoder: Google Gemma-3-12B.
• —Quantization to NVFP4 and the VAE/workflow packaging by coolthor.

This is a modified redistribution: the weights have been quantized to NVFP4 (changed from the FP8/BF16 originals) and the full VAE has been extracted to a standalone file.

License

This model and its derivatives are distributed under the LTX-2 Community License Agreement (dated January 5, 2026), inherited from the upstream LTX-2 base — see <https://github.com/Lightricks/LTX-2/blob/main/LICENSE>. A complete copy of the license is embedded in the checkpoint's safetensors metadata and reproduced in LICENSE in this repo.

Key points carried over from that license:

• —Reproduction, distribution and modification (including quantization) of LTX-2 and its derivatives are permitted.
• —Any derivative must be distributed under this same Agreement with a complete copy of the license included, and modified files must carry a notice that they were changed (done above).
• —The use-based restrictions in Attachment A (no unlawful use, no exploitation of minors, no non-disclosed machine-generated misinformation/impersonation, no military/weapons or malware use, etc.) apply and must be passed on to downstream recipients.
• —Entities with annual revenue ≥ USD $10,000,000 require a separate paid commercial license from Lightricks.

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