✅ Working Apple Silicon / macOS workaround for ComfyUI FP8 MPS

[vSnake87]

Working Apple Silicon / macOS workaround for ComfyUI FP8 MPS crash after updates

I’m sharing a working local workaround for Apple Silicon users running ComfyUI on macOS with the MPS backend and hitting this error:

TypeError: Trying to convert Float8_e4m3fn to the MPS backend but it does not have support for that dtype.

In my case, the issue returned after a ComfyUI update because the files I had previously patched were overwritten again.

What fixed it for me was patching two separate locations:

1. ComfyUI core
   /Applications/ComfyUI.app/Contents/Resources/ComfyUI/comfy/float.py

2. comfy_kitchen inside the local ComfyUI virtual environment
   ~/ComfyUI/.venv/lib/python3.12/site-packages/comfy_kitchen/backends/eager/quantization.py

Why both patches were necessary in my setup:

• one failure path happened in ComfyUI core inside stochastic_rounding(...)
• another failure path happened inside comfy_kitchen in dequantize_per_tensor_fp8(...)

The logic of the workaround is simple:

• if the tensor is on MPS
• move the FP8-related operation to CPU
• perform the conversion or dequantization there
• move the resulting tensor back to the original device if needed

After patching both files, the official LTX 2.3 workflow worked again correctly on my Apple Silicon Mac with MPS enabled.

More importantly, in my case this was not limited to a single workflow. After applying both patches, all FP8 models I personally tested in ComfyUI were able to launch and run without triggering the Float8_e4m3fn MPS backend crash. I cannot guarantee identical results for every environment, but on my machine this consistently resolved the FP8-on-MPS failure path.

Because updates can overwrite the modified files again, I wrapped the workaround into a small Python patcher script so I can re-apply it quickly after future ComfyUI updates.

Important notes:

• this is not an official upstream fix
• this is a local workaround
• it assumes the ComfyUI Desktop app path on macOS
• it also assumes a local ComfyUI venv layout similar to ~/ComfyUI/.venv/...
• users should review and adjust paths if their installation layout is different

Sanitized patcher script:

from pathlib import Path
from datetime import datetime
import py_compile
import shutil
import sys

HOME = Path.home()

FLOAT_PATH = Path("/Applications/ComfyUI.app/Contents/Resources/ComfyUI/comfy/float.py")
KITCHEN_PATH = HOME / "ComfyUI/.venv/lib/python3.12/site-packages/comfy_kitchen/backends/eager/quantization.py"

STAMP = datetime.now().strftime("%Y%m%d_%H%M%S")


def backup_file(path: Path):
    backup = path.with_name(path.name + f".bak_{STAMP}")
    shutil.copy2(path, backup)
    print(f"[backup] {path} -> {backup}")


def patch_float_py():
    path = FLOAT_PATH
    text = path.read_text()

    if 'on_mps = value.device.type == "mps"' in text:
        print("[ok] float.py already appears patched")
        return False

    start = text.find("def stochastic_rounding(value, dtype, seed=0):")
    end = text.find("\n# TODO: improve this?", start)

    if start == -1 or end == -1:
        raise RuntimeError("Could not find stochastic_rounding() boundaries in float.py")

    new_block = '''def stochastic_rounding(value, dtype, seed=0):
    if dtype == torch.float32:
        return value.to(dtype=torch.float32)
    if dtype == torch.float16:
        return value.to(dtype=torch.float16)
    if dtype == torch.bfloat16:
        return value.to(dtype=torch.bfloat16)
    if dtype == torch.float8_e4m3fn or dtype == torch.float8_e5m2:
        on_mps = value.device.type == "mps"
        if on_mps:
            value = value.cpu()

        generator = torch.Generator(device=value.device)
        generator.manual_seed(seed)
        output = torch.empty_like(value, dtype=dtype)
        num_slices = max(1, (value.numel() / (4096 * 4096)))
        slice_size = max(1, round(value.shape[0] / num_slices))

        for i in range(0, value.shape[0], slice_size):
            output[i:i+slice_size].copy_(
                manual_stochastic_round_to_float8(
                    value[i:i+slice_size], dtype, generator=generator
                )
            )

        return output

    return value.to(dtype=dtype)

'''

    backup_file(path)
    patched = text[:start] + new_block + text[end + 1 :]
    path.write_text(patched)
    py_compile.compile(str(path), doraise=True)
    print("[patched] float.py")
    return True


def patch_quantization_py():
    path = KITCHEN_PATH
    text = path.read_text()

    if 'target_device = x.device' in text and 'if x.device.type == "mps":' in text:
        print("[ok] quantization.py already appears patched")
        return False

    old = """def dequantize_per_tensor_fp8(
    x: torch.Tensor, scale: torch.Tensor, output_type: torch.dtype = torch.bfloat16
) -> torch.Tensor:
    dq_tensor = x.to(dtype=output_type) * scale.to(dtype=output_type)
    return dq_tensor
"""

    new = """def dequantize_per_tensor_fp8(
    x: torch.Tensor, scale: torch.Tensor, output_type: torch.dtype = torch.bfloat16
) -> torch.Tensor:
    target_device = x.device

    if x.device.type == "mps":
        x = x.cpu()
        scale = scale.cpu()

    dq_tensor = x.to(dtype=output_type) * scale.to(dtype=output_type)

    if target_device.type == "mps":
        dq_tensor = dq_tensor.to(target_device)

    return dq_tensor
"""

    if old not in text:
        raise RuntimeError("Could not find the original dequantize_per_tensor_fp8() block in quantization.py")

    backup_file(path)
    text = text.replace(old, new, 1)
    path.write_text(text)
    py_compile.compile(str(path), doraise=True)
    print("[patched] quantization.py")
    return True


def verify():
    float_text = FLOAT_PATH.read_text()
    kitchen_text = KITCHEN_PATH.read_text()

    float_ok = 'on_mps = value.device.type == "mps"' in float_text
    kitchen_ok = 'target_device = x.device' in kitchen_text and 'if x.device.type == "mps":' in kitchen_text

    print(f"[verify] float.py: {'OK' if float_ok else 'MISSING PATCH'}")
    print(f"[verify] quantization.py: {'OK' if kitchen_ok else 'MISSING PATCH'}")

    return float_ok and kitchen_ok


def main():
    try:
        patch_float_py()
        patch_quantization_py()
        ok = verify()

        if ok:
            print("\nDone. You can launch ComfyUI.")
        else:
            print("\nPatch was not fully applied.")
            sys.exit(2)

    except Exception as e:
        print(f"\n[ERROR] {e}")
        sys.exit(1)


if __name__ == "__main__":
    main()

How to use:

Save the script as something like patch_comfy_mps_fp8.py
Close ComfyUI
Run the script with Python
Re-open ComfyUI
Re-run your FP8 workflow

If anyone else on Apple Silicon tests this successfully on additional FP8 models or workflows, it would be useful to compare results.
patch_comfy_mps_fp8.py