unslothai/unsloth · error · ValueError

'{fam.name}' cannot run on Apple Silicon: its Modular Diffus

Error message

'{fam.name}' cannot run on Apple Silicon: its Modular Diffusers workflow places components through the Diffusers auto CPU offload, which needs a torch device exposing mem_get_info, and Metal (MPS) does not have it.{gguf_hint}

What it means

A modular-workflow family cannot run on Apple Silicon: the load path hands every non-CPU device to Diffusers' ComponentsManager.enable_auto_cpu_offload, which requires torch.<device>.mem_get_info, and torch.mps has never exposed it (NotImplementedError). The gate refuses before ~145 GB of downloads and before the resident pipeline is evicted.

Source

Thrown at studio/backend/core/inference/video.py:1115

                f"'{fam.name}' cannot load from a single .safetensors checkpoint: it is assembled "
                f"by its Modular Diffusers workflow, which builds every component from a repo. "
                f"Load the diffusers pipeline repo '{fam.base_repo}' for the full bfloat16 "
                f"model{gguf_hint}."
            )
        if fam.modular_workflow and kind == "pipeline":
            # Metal cannot place a modular workflow at all. _load_h3_modular_pipeline hands every
            # non-CPU device to ComponentsManager.enable_auto_cpu_offload, which reads
            # torch.<device>.mem_get_info and raises NotImplementedError for a device module
            # without one; torch.mps has never exposed it. Refuse here, before ~145 GB downloads
            # and the resident pipeline is torn down to make room for it.
            if resolve_diffusion_device_target().device == "mps":
                gguf_hint = (
                    f" Load a .gguf checkpoint from '{fam.gguf_repo}' instead, which runs on the "
                    f"native engine."
                    if fam.gguf_repo
                    else ""
                )
                raise ValueError(
                    f"'{fam.name}' cannot run on Apple Silicon: its Modular Diffusers workflow "
                    f"places components through the Diffusers auto CPU offload, which needs a "
                    f"torch device exposing mem_get_info, and Metal (MPS) does not have it."
                    f"{gguf_hint}"
                )
            # Same normaliser the load uses, so a malformed value raises the identical message it
            # would below and only a real scheme reaches the availability check.
            requested_scheme = normalize_transformer_quant(transformer_quant)
            # The base the modular load resolves for a pipeline kind IS repo_id, so a
            # variant-keyed checkpoint is judged against the one the load will ask for and
            # validation can never refuse a load that would have worked.
            quant_base = repo_id
            # "auto" is a request for the backend's own choice, not for a specific scheme, so it is
            # never refused: it simply stays on the released bfloat16 components.
            if requested_scheme is not None and requested_scheme != TQ_AUTO:
                # Asked per (scheme, TASK), not per scheme. A family can host one denoiser per
                # workflow partition in the same repo -- MiniMax-H3 hosts a keyframe (fl2va, which
                # also covers text-only) and a reference (ref2va) checkpoint -- and the two share

View on GitHub (pinned to 203007d190)

Solutions

If the family has a gguf_repo (the message appends the hint), load a .gguf checkpoint on the native engine instead.
Otherwise pick a non-modular supported family that runs on MPS.
Run the modular family on a CUDA host; no memory_mode or device override makes mem_get_info exist on MPS.

Example fix

# before (on Apple Silicon)
load_video_model(repo_id='<modular-family-pipeline-repo>')  # refused

# after (on Apple Silicon)
load_video_model(repo_id='<family-gguf-repo>', gguf_filename='model-Q4_K_M.gguf')  # native engine

Defensive patterns

Strategy: validation

Validate before calling

from core.inference.diffusion_device import resolve_diffusion_device_target
fam = _detect_load_family(repo_id, gguf_filename, family_override)
blocked_on_mps = (
    fam is not None and getattr(fam, 'modular_workflow', False)
    and resolve_diffusion_device_target().device == 'mps'
)
# if blocked_on_mps: use fam.gguf_repo + a .gguf file, or another family

Try / catch

try:
    load_video_model(repo_id=r)
except ValueError as e:
    if 'cannot run on Apple Silicon' in str(e) and fam.gguf_repo:
        load_video_model(repo_id=fam.gguf_repo, gguf_filename=pick_quant(fam.gguf_repo))
    else:
        raise

Prevention

Gate modular-workflow families out of the picker on MPS devices.
On Apple Silicon, prefer GGUF checkpoints which run on the native engine.
No memory_mode or device setting substitutes for the missing torch.mps.mem_get_info; do not try to override.

When it happens

Trigger: Requesting a pipeline-kind load of a modular-workflow family on a host whose resolve_diffusion_device_target().device == 'mps' (any Apple Silicon Mac with the default Metal device).

Common situations: Mac users selecting the largest modular models because they appear in the model list; configs synced from a CUDA machine to an M-series Mac; assuming MPS offload works like CUDA offload.

Related errors

AI-assisted analysis of unslothai/unsloth@203007d190 (2026-08-15). Data as JSON: /api/errors/8e34761f95e01f58. Report an issue: GitHub.