# ComfyUI-GGUF loads GGUF files using gguf.GGUFReader
reader = gguf.GGUFReader(model_path)

# Weights are stored as GGMLTensor objects (custom tensor class)
# that contain quantized data + metadata
for tensor in reader.tensors:
    state_dict[tensor.name] = GGMLTensor(
        tensor.data,
        tensor_type=tensor.tensor_type,  # e.g., Q8_0
        tensor_shape=tensor.shape
    )

class GGMLOps(comfy.ops.manual_cast):
    class Linear(GGMLLayer):
        def forward_ggml_cast_weights(self, input):
            # Dequantize weights ON-THE-FLY
            weight, bias = self.cast_bias_weight(input)
            return torch.nn.functional.linear(input, weight, bias)

    def get_weight(self, tensor, dtype):
        # THIS IS THE KEY FUNCTION
        weight = dequantize_tensor(tensor, dtype, self.dequant_dtype)
        return weight

def dequantize_blocks_Q8_0(blocks, block_size, type_size, dtype=None):
    """
    Q8_0 format:
    - Block size: 32 values
    - Each block: 1 × FP16 scale + 32 × int8 quantized values
    - Formula: output = int8_value × scale_fp16
    """
    n_blocks = blocks.shape[0]
    d, qs = split_block_dims(blocks, 2)  # d=scale (FP16), qs=int8 values

    # Convert scale to FP16
    d = d.view(torch.float16).to(dtype)

    # Get int8 quantized values
    qs = qs.view(torch.int8)

    # Dequantize: multiply int8 by FP16 scale
    return (d * qs)  # Result is FP16 with quantization artifacts

User enters prompt
    ↓
ComfyUI loads T5-XXL GGUF encoder
    ↓
GGUF file contains:
  - 169 tensors in Q8_0 format (77%)
  - 50 tensors in F32 format (23%)
    ↓
During text encoding:
  1. Input text → tokenizer → token IDs
  2. Token IDs fed to T5 model
  3. For each layer:
     - Load quantized weights (Q8_0)
     - Call dequantize_blocks_Q8_0()
     - int8 × FP16_scale → FP16 weights
     - Use FP16 weights for torch.nn.functional.linear()
  4. Output: text embeddings (shape: [77, 4096])
    ↓
Text embeddings fed to Flux/HunyuanVideo diffusion model
    ↓
Generated image/video

# Load standard FP16 model
model = T5EncoderModel.from_pretrained("google/t5-v1_1-xxl", dtype=torch.float16)

# Simulate Q8_0 quantization on ALL weights
for param in model.parameters():
    if 'weight' in name:
        # Reshape into blocks of 32
        blocks = param.reshape(-1, 32)

        # Get scales per block (same as ComfyUI-GGUF)
        scales = blocks.abs().max(dim=1, keepdim=True)[0]

        # Quantize to int8 (same as ComfyUI-GGUF)
        quantized = torch.round(blocks / scales * 127.0)
        quantized = torch.clamp(quantized, -127, 127)

        # Dequantize (same as ComfyUI-GGUF)
        dequantized = (quantized / 127.0) * scales

        # Replace weights with dequantized version
        param.copy_(dequantized)