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.
File
SenseNova-U1.5-8B-MoT-Preview-Q4_0-v2.gguf
Size
10.13 GiB (10,875,444,576 bytes)
Source
16-shard BF16 release (~50 GB)
Fits
16 GB VRAM fully resident; 12 GB with layer offload
Shim required
No — verified on the stock node
The file must go in ComfyUI/models/gguf/, notComfyUI/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:
Rule
Type
1D tensors (bias, LayerNorm, RMSNorm) and anything ≤ 1024 params
F32
Tensors owned by a module that is notnn.Linear, plus the two FM embedders
F16
Conv kernels / anything whose last dim isn't a multiple of 32
F16
Everything else — the large 2D Linear weights
Q4_0
Of the 1116 tensors: 589 Q4_0, 11 F16, 516 F32. The Q4_0 set includes
all 588 attention/MLP weights across the 42 layers and both _mot_gen branches
plus lm_head, 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:
Tensor
Real module
Failure in v1
language_model.model.embed_tokens.weight
nn.Embedding
Embedding lookup returns rows of 4096 // 32 * 18 = 2304 instead of 4096 → RuntimeError: The size of tensor a (4096) must match the size of tensor b (2304)
fm_modules.timestep_embedder.mlp.{0,2}.weight
nn.Linear
modeling_fm_modules.py casts activations with t_freq.to(self.mlp[0].weight.dtype); on GGUFLinear that dtype is the storage dtype torch.uint8 → RuntimeError: mat1 and mat2 must have the same dtype, but got Byte and BFloat16
fm_modules.noise_scale_embedder.mlp.{0,2}.weight
nn.Linear
same as above
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:
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.
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.yamlunder the key gguf:
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:
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
Input
Value
model_path
the config/tokenizer directory from step 4
sensenova_u1_src
leave as-is (auto-resolved)
device
cuda
dtype
bfloat16
attn_backend
auto
device_map
none — must be none when a GGUF is selected
max_memory
empty
vram_mode
full on 16 GB, balanced on 12 GB
gguf_checkpoint
SenseNova-U1.5-8B-MoT-Preview-Q4_0-v2.gguf
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.
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
Input
Default
Notes
prompt
—
plain text, no encoder node
resolution
2048x2048|1:1
native sizes only, see below
cfg_scale
4.0
cfg_norm
none
global / channel / cfg_zero_star
timestep_shift
3.0
sampler schedule shift
cfg_interval_start / _end
0.0 / 1.0
window where CFG applies
num_steps
50
16 is fine for drafts
batch_size
1
seed
—
think_mode
false
model reasons before drawing; text on the think_text output
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:
Ratio
Pixels
Ratio
Pixels
1:1
2048×2048
2:1
2880×1440
16:9
2720×1536
1:2
1440×2880
9:16
1536×2720
3:1
3456×1152
3:2
2496×1664
1:3
1152×3456
2:3
1664×2496
4:3
2368×1760
3:4
1760×2368
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:
Run
Steps
Size
Wall time
t2i, full, includes loading the 10.13 GiB file
16
2048×2048
179 s
edit, balanced, 2.1 MP, includes reload
8
1440×1440
219 s
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.
