For now, I do not know whether this actually works in ComfyUI, but I was able to complete the conversion locally. I cannot upload the converted model itself because of my Hugging Face storage quota, but I uploaded the converter and its documentation here:
Direct answer
I could not find a publicly available FireRed Image Edit 1.1 native INT8 ConvRot checkpoint, or a confirmed official release plan for one.
There are already public requests for it:
At the time of writing, the GitHub issue is still open, with no assignee, milestone, branch, or pull request attached.
The runtime side is less uncertain: ComfyUI v0.27.0 added native INT8 ConvRot support, and the current comfy-quants INT8 tensorwise documentation describes the stock-ComfyUI format as:
int8_tensorwise- ComfyUI
>= 0.27.0
- NVIDIA compute capability
SM >= 7.5
- regular-Hadamard ConvRot with group size 256 by default
- no retired INT8-Fast custom loader required
So the missing part was not the general ComfyUI runtime format. The missing part was a FireRed-specific exporter or checkpoint.
The script above provides a local conversion path, but the result must still be treated as experimental because I have not confirmed stock-ComfyUI loading or image-generation E2E.
Current result
| Item |
Status |
| Official FireRed 1.1 source conversion |
Completed |
| Source shards |
5 |
| Source tensors |
1,933 |
| INT8-quantized weights |
839 |
| ConvRot-applied weights |
839 |
| Tensors copied unchanged |
1,094 |
| Output tensors |
3,611 |
| Output size |
20,555,642,776 bytes |
| Safetensors header verification |
Passed |
__index_timestep_zero__ in source |
Absent |
__index_timestep_zero__ in output |
Absent |
| Stock ComfyUI load |
Not confirmed |
| Image generation |
Not confirmed |
| FP8-vs-INT8 quality comparison |
Not performed |
| Inference speed and VRAM |
Not measured |
There is a useful structural sanity check in the tensor counts:
1,094 copied tensors
+ 839 × 3 generated tensors
(weight + weight_scale + comfy_quant)
= 3,611 output tensors
That does not prove that FireRed inference works, but it makes an accidental tensor-loss or output-count mismatch less likely.
Shortest conversion route
Install PyTorch using the appropriate command for the local CUDA environment, then install the other dependencies:
python -m pip install -U safetensors numpy huggingface_hub
With no source or path arguments, the converter downloads the official transformer files under:
./FireRed-Image-Edit-1.1/
and writes:
./firered-image-edit-1.1-int8-convrot.safetensors
Run:
python convert_firered_image_edit_int8_convrot.py --device cuda:0
The download uses huggingface_hub.snapshot_download(local_dir=...) and only requests the transformer safetensors, index, and transformer config rather than the complete repository contents.
A dry header/contract check can be run before quantization:
python convert_firered_image_edit_int8_convrot.py \
--source ./FireRed-Image-Edit-1.1/transformer \
--dry-run
For an already-downloaded local model:
python convert_firered_image_edit_int8_convrot.py \
--source ./FireRed-Image-Edit-1.1/transformer \
--output ./firered-image-edit-1.1-int8-convrot.safetensors \
--device cuda:0
When --source is supplied, the script does not download from Hugging Face.
Expected stock-ComfyUI path
This is the expected loading route based on the native format and the official FireRed workflow, not a confirmed E2E result:
-
Use ComfyUI 0.27.0 or newer.
-
Place the converted file under:
ComfyUI/models/diffusion_models/
-
Open the official FireRed 1.1 workflow.
-
In its UNETLoader, replace the official BF16 transformer with:
firered-image-edit-1.1-int8-convrot.safetensors
-
Leave the loader dtype setting at:
default
The official workflow already loads its transformer through the core UNETLoader from models/diffusion_models, so no workflow redesign should be necessary merely to select a different standalone transformer file.
However, that is still an expected integration path. It is not evidence that this particular converted checkpoint has completed a FireRed generation successfully.
Important limitation: a valid safetensors file, correct tensor counts, and valid comfy_quant markers are not the same thing as a successful model load and image-generation result.
What the converter does
The exporter is intended for machines where disk space is available but holding the complete source and destination state dictionaries in RAM would be undesirable.
Its main behavior is:
- download the official FireRed transformer with
snapshot_download(local_dir=...), or accept a local source;
- read sharded safetensors inputs;
- validate the expected FireRed tensor-name and tensor-shape contract;
- process selected rank-2 weights one at a time;
- apply regular-Hadamard ConvRot with group size 256;
- quantize each selected weight to per-output-row INT8;
- write
weight, weight_scale, and comfy_quant tensors;
- copy non-selected source tensors directly from their safetensors payload;
- append converted data incrementally to a disk-backed temporary payload;
- assemble the final safetensors file only after all source tensors are processed;
- print tensor-level progress, elapsed time, approximate ETA, and memory information to standard output;
- maintain a journal so an interrupted conversion can resume.
It does not load the entire FireRed transformer into a single Python state dictionary.
The temporary files are stored beside the requested output:
<output>.payload.tmp
<output>.journal.json
<output>.building.tmp
Running the same command again resumes from a compatible journal by default. --restart discards compatible temporary state and starts over.
The design deliberately trades disk usage for lower peak memory pressure. During finalization, temporary disk use can approach roughly two copies of the final checkpoint, in addition to the downloaded BF16 source.
Why the result appears structurally plausible
This is not an official FireRed exporter from Comfy-Org or FireRedTeam. The structural case is instead based on several narrower observations.
1. FireRed uses a Qwen Image transformer architecture
The official FireRed transformer config identifies the transformer class as:
{
"_class_name": "QwenImageTransformer2DModel",
"num_layers": 60,
"attention_head_dim": 128,
"num_attention_heads": 24
}
That makes the existing Qwen Image quantization machinery a reasonable starting point, but architectural relation alone does not guarantee an interchangeable exporter.
2. The target storage format is documented
The comfy-quants documentation documents stock-ComfyUI-native int8_tensorwise checkpoints and their ConvRot settings.
Its listed first-party model-family configurations currently include Qwen Image, Qwen Image Edit, Qwen Image Layered, and LTX-2—not FireRed. Therefore, this converter should not be described as an official comfy-quants FireRed configuration.
It instead reproduces the documented storage and marker contract for the FireRed transformer layout.
3. The complete FireRed contract matched
The converter expected 839 target weights.
For the official FireRed 1.1 transformer:
- all 839 expected names were present;
- all selected tensors were rank 2;
- all selected input dimensions were compatible with ConvRot group size 256;
- no partial-contract override was needed.
The exporter refuses an incomplete official-model match unless the explicitly unsafe --allow-partial-contract option is used.
4. Non-target tensors were retained
The source contained 1,933 tensors:
839 selected weights + 1,094 non-selected tensors = 1,933
The output contained:
1,094 unchanged tensors
+ 839 INT8 weights
+ 839 FP32 weight scales
+ 839 comfy_quant marker tensors
= 3,611 tensors
5. The reference-conditioning sentinel was not invented
The source transformer did not contain:
__index_timestep_zero__
The exporter did not add it.
This matters because current ComfyUI model detection treats that key as a behavioral signal rather than decorative metadata.
The converter therefore follows a source-preserving rule:
preserve if present
do not inject if absent
That is more conservative than importing a Qwen Image Edit adapter decision without confirming that FireRed uses the same reference-conditioning convention.
None of these checks proves correct inference. Together, they support the narrower statement that the artifact is structurally plausible and internally consistent.
Observed conversion behavior
One full conversion reported:
| Measurement |
Observed value |
| Conversion time |
about 536 seconds |
| Peak CUDA allocated memory |
about 278 MiB |
| Peak CUDA reserved memory |
about 454 MiB |
| Final checkpoint |
about 20.56 GB |
These are conversion-time observations from one system, not general hardware requirements.
In particular:
- conversion GPU memory is not inference VRAM;
- the result does not establish generation speed;
- the report did not record an authoritative peak process RSS, so it does not establish an exact CPU-RAM requirement;
- output finalization and source storage require substantial disk space.
The low reported CUDA allocation is consistent with processing one selected weight at a time rather than moving the full transformer onto the GPU.
What this does not establish about image quality
The original motivation—text artifacts and facial drift in FP8—makes INT8 ConvRot a reasonable format to investigate, but there is no basis yet for saying that it will definitely solve either problem.
ConvRot changes the quantization recipe. It does not change the underlying FireRed model or guarantee preservation of every high-frequency detail.
A meaningful quality claim would need to separate at least:
- the exact FP8 checkpoint and its quantization recipe;
- source model revision;
- selected and excluded layers;
- workflow version;
- text encoder and VAE files;
- Lightning LoRA usage;
- sampler, scheduler, step count, and seed;
- offload behavior;
- the INT8 ConvRot artifact itself.
The appropriate controls for interpreting results would be the same source images, prompts, workflow, seed, sampler, and steps across:
- BF16;
- the original FP8 checkpoint;
- this INT8 ConvRot conversion;
- a high-quality GGUF such as Q8_0 or Q6_K.
Until such a matched comparison exists, the safe claims are limited to:
- the conversion completed;
- the output structure passed internal checks;
- the model size was reduced;
- native ComfyUI support for the target storage format exists.
It would be premature to claim:
- improved text fidelity;
- reduced facial drift;
- BF16-equivalent quality;
- faster generation;
- lower inference VRAM than every GGUF alternative.
Existing FireRed alternatives
The official FireRed 1.1 ComfyUI repository currently contains:
- the approximately 40.9 GB BF16 transformer safetensors;
- a BF16 GGUF;
- Q4_1 GGUF;
- Q4_K_M GGUF;
- the official ComfyUI workflow and supporting model files.
It does not currently list a native FireRed transformer using stock-ComfyUI int8_tensorwise ConvRot.
A community FireRed 1.1 GGUF repository includes a wider range, including:
- Q6_K, approximately 16.8 GB;
- Q8_0, approximately 21.8 GB.
Those GGUF files are not the same format or kernel path as native INT8 ConvRot. They are nevertheless useful practical alternatives and comparison controls because they already exist as downloadable model artifacts.
The relevant distinction is:
| Route |
Availability |
Main uncertainty |
| Official BF16 |
Available |
High storage and memory demand |
| Official Q4 GGUF |
Available |
Greater quantization pressure |
| Community Q6_K/Q8_0 GGUF |
Available |
Separate GGUF loader/kernel path |
| Local INT8 ConvRot conversion |
Converter available |
FireRed stock-ComfyUI E2E unconfirmed |
| Official INT8 ConvRot release |
Not currently published |
No confirmed release plan found |
Additional converter commands
Specify download and output paths
python convert_firered_image_edit_int8_convrot.py \
--repo-id FireRedTeam/FireRed-Image-Edit-1.1 \
--local-dir ./downloads/FireRed-Image-Edit-1.1 \
--output ./models/firered-image-edit-1.1-int8-convrot.safetensors \
--device cuda:0
Use only already-downloaded Hugging Face files
python convert_firered_image_edit_int8_convrot.py \
--source ./FireRed-Image-Edit-1.1/transformer \
--local-files-only \
--output ./firered-image-edit-1.1-int8-convrot.safetensors \
--device cuda:0
When --source is used, no Hub download is attempted, so --local-files-only is normally unnecessary in that case.
Calculate a final SHA-256
python convert_firered_image_edit_int8_convrot.py \
--source ./FireRed-Image-Edit-1.1/transformer \
--output ./firered-image-edit-1.1-int8-convrot.safetensors \
--device cuda:0 \
--hash-output
Hashing performs another complete read of the final file.
Restart instead of resuming
python convert_firered_image_edit_int8_convrot.py \
--source ./FireRed-Image-Edit-1.1/transformer \
--output ./firered-image-edit-1.1-int8-convrot.safetensors \
--device cuda:0 \
--restart
CPU conversion
python convert_firered_image_edit_int8_convrot.py \
--source ./FireRed-Image-Edit-1.1/transformer \
--device cpu \
--math-dtype float32
CPU conversion is supported by the script, but it can be much slower.
Safety defaults
For the official FireRed 1.1 source, the following defaults should normally remain unchanged:
--convrot
--convrot-groupsize 256
--math-dtype source
--resume
--allow-partial-contract is not intended for the official model. It disables an important compatibility check and is only an investigation option for modified layouts.
References
FireRed
ComfyUI INT8 ConvRot
Converter
Existing GGUF controls
Current status: the converter and documentation are public, the full local conversion and safetensors-header checks completed, and the converted model weights will not be uploaded because of my Hugging Face storage quota. Stock-ComfyUI loading, FireRed image generation, perceptual quality, inference speed, and inference VRAM remain unconfirmed.