Runtime44 Image To Latent Noise

Runtime44 Image To Latent Noise does something you can't do with the stock nodes: it converts an image into structured latent noise. Regular noise is random. This is noise that still carries the color structure of whatever image you fed it. The output is a LATENT - the same kind of thing a VAE Encode produces - that you can use as the starting point for a sampling pass.

Let me be honest about what this is and isn't. This is a creativity/experimentation node, not a workhorse. It's for when you want a generation that's guided by the color and texture skeleton of an image without doing a normal img2img pass. The README positions it plainly as "convert an image into latent noise," and that's the whole job.

How it works

The mechanism is delightfully simple and a little weird:

1. The image is quantized to a small number of colors (the colors input, default 8). That posterizes it down to its palette skeleton.
2. The pixel data is shuffled randomly, seeded by the seed input (default 44). The palette stays; the positions scramble.
3. The shuffled result is VAE-encoded into a latent.

So what you get is a latent that has the color statistics of your image arranged as noise. The seed makes it fully reproducible - same inputs, same latent, every time.

The inputs and what they actually do

• image - anything with an IMAGE output; its colors become the noise's palette.
• vae - the VAE used to encode it. Needs to match the checkpoint family you're sampling with (SDXL VAE for SDXL, etc.), same as any encode.
• colors - 2 to 128, default 8. Lower = chunkier, more posterized color blocks; higher = closer to the original's color richness (but it's still being shuffled, so "richness" gets noisy fast).
• seed - the shuffle seed. Change it to get different noise with the same palette.

Output is one LATENT named "Latent Noise."

How you'd actually use it

The natural move is to feed this latent into a KSampler as your latent_image. How much the result follows your source image depends entirely on denoise:

• High denoise (~1.0) - the noise is basically just a texture seed; you get a fresh image that may loosely inherit the palette mood.
• Low denoise (0.3–0.6) - the color structure shows through, like a very rough color-guide for the generation.

It's a fun node for abstract work, color-led experiments, and "what if this image were reborn from its own noise" explorations. It's not a tool for precision - if you want controlled img2img, that's what regular VAE Encode + KSampler at moderate denoise is for, and this node won't beat it on fidelity.

Installing

It ships in Runtime44 ComfyUI Nodes, under the default "sd" category:

cd ComfyUI/custom_nodes
git clone https://github.com/runtime44/comfyui_r44_nodes
cd comfyui_r44_nodes
python -m pip install -r requirements.txt   # or: uv pip install -r requirements.txt

Restart ComfyUI, or search "Runtime44" in ComfyUI Manager. It only needs Pillow and the VAE - the pack's heavy CUDA wheels aren't involved, but the shared requirements file installs them anyway. The pack has been dormant since mid-2024; for a node this niche, there's not a lot of community lore to be missing out on. Give it a try with a colorful source image and a denoise around 0.4 - that's where it actually gets interesting.