IO Checkpoint Loader

A pipe is great until you hit the one node that wants a plain MODEL socket. IO Checkpoint Loader [SML2] is the adapter: feed it a PIPE, get back every field inside it as an individual output - and, going the other way, push new values in and get an updated pipe out.

Why you'd reach for it

Every pack that invented a context bus had to ship an unpacker, because third-party nodes can't read your dict. rgthree calls it an exploder; here it's this. You'll use it in three situations:

1. You need model for a node that predates pipes - a ControlNet applier, a PuLID node, CFGGuider for a custom sampler.
2. You need sigmas for SamplerCustomAdvanced, which is the only sanctioned way to use an explicit schedule in this pack.
3. You want to override one value without rebuilding the loader - splice a different latent, force 20 steps, hand-write the seed.

How it works

It's a merge node wearing an unpacker's clothes. The pipe input arrives, then every direct input you connect wins over the pipe's copy of that field, and the result goes out both as a new pipe and as 21 individual outputs. Sockets come in stable order - pipe, model, clip, vae, audio_vae, latent, steps, cfg, sampler_name, scheduler, flux_guidance, clip_skip, width, height, batch_size, model_name, vae_name, lora_names, seed, denoise, and finally sigmas - so existing links don't shuffle when the pack updates. Missing values come out as None rather than blowing up.

Two behaviours worth knowing precisely. When width and height are absent, a latent supplies them using its own spatial downscale ratio (8 by default), so an SDXL latent implies 1024×1024 without you setting anything. And sigmas sits last, after denoise: connect a SIGMAS from the Qwen Image 2.1 Scheduler - or any compatible scheduler - and it overrides the pipe's schedule while being stored in the returned pipe. That ordering is a compatibility promise, not an accident.

Inputs that actually get used

All inputs are optional; that's the point. In practice you connect four things:

• pipe - the loader's output (or another IO node's, or the sampler's returned pipe).
• model - when you're branching to a non-pipe node.
• sigmas - for the custom-sampler route.
• latent - when you want to override the loader's latent with something you built elsewhere, e.g. the target latent from Text Encode Qwen Image 2.1.

The typed scalars (steps, cfg, denoise, clip_skip, flux_guidance, seed) are the ones people convert from widgets downstream. Handy wiring: run steps and denoise from here into the Qwen Image 2.1 Scheduler, because that scheduler does not read steps out of an incoming pipe - it only takes them from its own widgets or from a live wire.

Wiring it to a custom sampler

The canonical example from the pack's own guide:

Smart Model Loader PIPE → Qwen Image 2.1 Scheduler PIPE → IO Checkpoint Loader
                                                           ├─ model → CFGGuider
                                                           ├─ latent → SamplerCustomAdvanced.latent_image
                                                           └─ sigmas → SamplerCustomAdvanced.sigmas

That's how you get Flux guidance applied too, incidentally: flux_guidance lives in the pipe as a number, and KSampler Pipe deliberately does not apply it. Pull it out here, feed a FluxGuidance node, and send that conditioning to the sampler.

Installing it

Same pack, one install. From ComfyUI Manager search Smart Model Loader Nova, or:

cd ComfyUI/custom_nodes
git clone https://github.com/r-vage/ComfyUI_SmartModelLoader_Nova.git
cd ComfyUI_SmartModelLoader_Nova
python -m pip install -r requirements.txt

Use ComfyUI's Python environment and restart afterwards. Everything in this pack shares the optional Nunchaku/PuLID dependencies, but this node needs none of them - plain checkpoint workflows are covered by the base requirements.

Where people get burned

The stale-pipe trap is the real one. Because the returned pipe carries everything, it's easy to unpack a model from a pipe assembled before your LoRA applier ran, and quietly sample the base weights. The wire is connected; the contents are wrong. With a pipe you can't see that by looking, which is exactly the debugging cost the plumbing layer trades for tidiness.

Don't assume the pipe has what you want. Pull sampler_name and scheduler and you get None if the loader's Sampler section was disabled - outputs are * wildcards in the schema, so nothing complains until something downstream fails.

Rename nothing. The node's ID is IO Checkpoint Loader [SML2]; if a workflow references the original pack's IO Checkpoint Loader without the suffix, it belongs to that pack, not this one, and installing Nova won't satisfy it.