hoidhxd/SenseNova-U1.5-8B-GGUF-v2

SenseNova-U1.5-8B-MoT-Preview — GGUF Q4_0 (v2)

Q4_0 GGUF build of SenseNova-U1.5-8B-MoT-Preview, for running the model locally in ComfyUI on a consumer GPU.

v2 needs no patch file. The v1 repo required a hand-installed compatibility shim before it would load. This build keeps the offending tensors dense, so it works with the stock node as shipped. Same VRAM at runtime, ~900 MB more on disk. If you are on v1, switch.

The file must go in ComfyUI/models/gguf/, not ComfyUI/models/unet/ — see step 3.

Architecture: NEO-unify

SenseNova U1 is a native multimodal model — one graph handles text and pixels end to end.

• —🚫 No external text encoder (no CLIP, no T5).
• —🚫 No external VAE.

So the ComfyUI graph is just two nodes: a loader and a sampler. There is nothing else to wire up.

Quantization details

Converted directly from the BF16 safetensors. The type of every tensor is chosen by an explicit rule, not by a try/except fallback:

Of the 1116 tensors: 589 Q4_0, 11 F16, 516 F32. The Q40 set includes all 588 attention/MLP weights across the 42 layers and both `motgen` branches plus `lmhead`, so image quality is unchanged from v1.

A *.plan.json manifest listing the exact type of every tensor is uploaded alongside the model.

What changed from v1

diffusers' GGUF quantizer only swaps nn.Linear for GGUFLinear. Every other module keeps the raw Q4_0 block bytes and crashes. v1 quantized five tensors it shouldn't have; v2 keeps them dense:

Six Conv2d kernels — patch_embedding (1024, 3, 16, 16), dense_embedding (4096, 1024, 2, 2) and fm_head.conv1/conv2 (…, 3, 3), each in both the vision tower and its _mot_gen twin — survived v1 only because their last dimension is the kernel size (16, 3 or 2), which isn't a multiple of 32: the quantizer raised and v1's except branch fell back to F16. That is exactly the "6 unaligned tensors" v1 reported. v2 declares them dense on purpose.

Note that dense_embedding is a 2×2 Conv2d that merges four vision patches into one LLM token (downsample_ratio: 0.5), despite the Linear-sounding name. lm_head is the only similarly-named tensor that really is an nn.Linear, and it stays Q4_0.

Cost: ~+900 MB on disk (the embedding is 622 M params: 350 MB at Q4_0 vs 1,245 MB at F16). Runtime VRAM is identical to v1 — v1's shim dequantized those same tensors to bf16 at load time anyway.

Using this model in ComfyUI

Tested on Windows 11 + RTX 5060 Ti 16 GB, ComfyUI with a Python 3.13 venv. Linux is the same apart from paths.

Throughout, <ComfyUI> is your ComfyUI root (e.g. D:\ComfyUI) and <python> is the interpreter ComfyUI itself runs on — not your system Python. For a portable build that is <ComfyUI>\..\python_embeded\python.exe; for a venv install, <ComfyUI>\venv\Scripts\python.exe (Windows) or <ComfyUI>/venv/bin/python (Linux).

1. Install the custom nodes

Install ComfyUI-SenseNova-U1 through ComfyUI Manager, or clone it:

git clone https://github.com/OpenSenseNova/ComfyUI-SenseNova-U1 <ComfyUI>/custom_nodes/ComfyUI-SenseNova-U1

2. Install the runtime and the GGUF extra

The nodes need the sensenova-u1 runtime package plus the GGUF dependencies. Install both into ComfyUI's Python:

<python> -m pip install -r <ComfyUI>/custom_nodes/ComfyUI-SenseNova-U1/requirements.txt

<python> -m pip install "gguf>=0.10.0" "diffusers>=0.30.0" accelerate transformers

requirements.txt pulls sensenova-u1 from a GitHub release tarball, which is intentional — a git+https install would drag in hundreds of MB of evaluation submodules.

3. Put the GGUF where the node actually looks

`ComfyUI/models/unet/` does not work. The SenseNova U1 Local Loader scans exactly two folder names, gguf and diffusion_models, and diffusion_models filters on ComfyUI's supported_pt_extensions, which does not include .gguf. Anything in unet/ is invisible to the node and the dropdown comes up empty.

Download into <ComfyUI>/models/gguf/:

hf download hoidhxd/SenseNova-U1.5-8B-GGUF-v2 SenseNova-U1.5-8B-MoT-Preview-Q4_0-v2.gguf --local-dir <ComfyUI>/models/gguf

If you already have the file elsewhere (a different drive, say) don't copy 10 GiB around — register the directory in <ComfyUI>/extra_model_paths.yaml under the key `gguf`:

ai_models:
    base_path: C:/Users/Admin/ai/models
    gguf: SenseNova-U1.5-8B-GGUF-v2

The key name is what matters. ComfyUI gives an unrecognised folder name an empty extension set, and an empty set means "no filter" — which is why .gguf files surface under gguf but not under diffusion_models.

Restart ComfyUI after adding files; the dropdown is built at startup.

4. Get the config and tokenizer

The GGUF holds weights only. The loader still needs the config and tokenizer from the base repo — but not the 50 GB of safetensors:

hf download sensenova/SenseNova-U1.5-8B-MoT-Preview --local-dir <somewhere>/SenseNova-U1.5-8B-MoT-Preview --include "*.json" "*.txt"

That yields ~5 MB:

config.json  added_tokens.json  special_tokens_map.json
tokenizer_config.json  vocab.json  merges.txt
model.safetensors.index.json

This directory is what you type into the loader's model_path.

5. Coming from v1? Remove the shim

If you previously installed <ComfyUI>/custom_nodes/sensenova_u1_embed_fix/, delete that folder. Leaving it in place is not fatal — it only touches tensors that are already dense here, so it becomes a no-op — but it is dead weight and will confuse the next person to read your install.

Fresh installs: skip this step. There is nothing to install.

6. Build the workflow

Two nodes, one link:

[SenseNova U1 Local Loader] --u1_model--> [SenseNova U1 Local Text to Image] --images--> [Save Image]

SenseNova U1 Local Loader

vram_mode replaced the old prefetch_count input:

• —full — every weight stays on the GPU. Fastest, ~2× the offload modes.
• —balanced — asynchronous layer prefetch, overlaps host→device copies with compute. Use this on 12 GB.
• —low — synchronous one-layer-at-a-time swap. Smallest footprint, slowest.

device_map is for splitting across multiple GPUs and is mutually exclusive with vram_mode; leave it none for single-GPU use.

SenseNova U1 Local Text to Image

U1.5 samples only at its own native resolutions. Pick the aspect ratio you want and downscale afterwards if you need a specific pixel size:

Example prompt:

A cinematic, dynamic shot of a terrified old man frantically running away from a massive, shadowy monster in a dark, foggy forest, high contrast, 8k resolution, photorealistic.

Also available: SenseNova U1 Local Image Edit (image + instruction) and SenseNova U1 Local Interleave (alternating text and images). Ready-made graphs ship in the node's example_workflows/ folder.

7. VRAM and timing

Measured on an RTX 5060 Ti 16 GB with this v2 file on the stock node — no shim installed:

At vram_mode=full the weights sit at 10.13 GiB allocated after load; sampling 2048² runs at 11.84 GiB steady with a peak of 12.19 GiB allocated (12.7 GiB reserved by the allocator). The edit run in balanced mode peaked at just 4.85 GiB allocated, with the weights streamed from host memory.

batch_size=2 at 2048² peaked at ~14.2 GiB in our v1 tests, about as far as a 16 GB card goes — go balanced beyond that.

Image editing needs more room than generation. The edit node runs the source image and the generated one through the model together; at full with the node's stock 4.19 MP target it OOMs on 16 GB (11.81 GiB weights plus a 2.27 GiB allocation). Use vram_mode=balanced and lower the megapixel target to ~2.1 for editing.

Every run above includes a model reload, because each changed something in the loader's cache key. Changing `vram_mode`, `model_path`, `dtype`, `device_map` or the GGUF selection forces a full reload — keep them stable between generations and only the first run pays the load cost.

Troubleshooting

Download

hf download hoidhxd/SenseNova-U1.5-8B-GGUF-v2 SenseNova-U1.5-8B-MoT-Preview-Q4_0-v2.gguf --local-dir .

License

Inherits the license of the base model, sensenova/SenseNova-U1.5-8B-MoT-Preview.