MiniT2I Sampler

Most ComfyUI workflows are a small city of nodes: load a checkpoint, hook up a CLIP encoder, build conditioning, pick a latent, sample, then VAE-decode the result. MiniT2I throws that whole map away. This single node is the pipeline - you type a prompt, set four numbers, and an IMAGE comes out the other end. No VAE, no latent space, no separate text encoder wiring unless you want it. If that sounds like cheating, it kind of is: MiniT2I is a deliberately tiny pixel-space text-to-image model, and niknah's sampler node wraps encoding, denoising and output in one box.

What you're actually running

MiniT2I isn't a familiar name in the SD/SDXL family, and that's the point. It's an open research release from a group of MIT students (Xianbang Wang et al.), billed honestly as "a simple pixel-space text-to-image generator baseline." Where Flux and its 12B cousins denoise in a compressed latent space, MiniT2I works directly in 512×512 RGB with a compact diffusion transformer (the MM-JiT architecture) and a flan-t5-large text encoder. The r/StableDiffusion reception when it landed was mostly warmth - people were glad "small and simple" was being taken seriously again after a long run of bigger-is-better. It won't out-detail a 12B model, but it sips VRAM - about 2.6GB for b16 and 4.3GB for l16, per the README - which means it actually runs on cards where newer checkpoints just fail to load.

How it works

The node pulls MiniT2I/MiniT2I from Hugging Face on first use, then runs the whole flow internally: flan-t5-large encodes your prompt, the transformer denoises 512×512 RGB via flow-matching velocity prediction with an Euler-style step, and CFG is applied for you against a masked-out empty prompt. That last bit is worth knowing - there's no negative prompt input, because the uncond branch is generated internally. You set the strength with guidance and move on.

One thing the source makes clear: this is a flow-matching model, and the sampler sits inside its own custom scheduler rather than the ComfyUI sampler dropdown. The node defaults to 10, which is optimistic - the author's own example workflow and the community's Hugging Face Space both run 100 steps at guidance 2.5. Start at 10 to test your wiring, then crank it to 50–100.

Inputs and outputs

The four fields a beginner actually sets:

• prompt - multiline, and it's the whole input. No negatives, no weighting syntax to worry about.
• steps - default 10, range 0–4096. Quality scales with this; see above.
• guidance - default 2.5, and that's the sweet spot the author ships with.
• seed - default 1. Standard: same seed, same image.

Optionally, model and text_encoder (both MODEL type) wire in the MiniT2I Loader and MiniT2I Text Encoder Loader - the tooltips literally say "Use MiniT2I Loader" and "Use MiniT2I Text Encoder Loader." The author's example workflow connects both, and v1.0.2 split the pack into loader + inference nodes specifically so ComfyUI can manage VRAM instead of the sampler holding everything. Wire them in.

The single output is IMAGE, and it's ready to go - straight into a PreviewImage or SaveImage. There is no VAE to run because there's no latent to decode.

Installing and running it

ComfyUI Manager → search "MiniT2I", install, restart. Or by hand:

cd ComfyUI/custom_nodes
git clone https://github.com/niknah/MiniT2I-ComfyUI

Then restart ComfyUI. Two things to know before your first queue: the pack declares zero pip dependencies (it silently leans on transformers, diffusers and huggingface_hub that most ComfyUI environments already have), and it's built on the newer comfy_api extension framework, so you need a current ComfyUI - an old install won't even list the nodes. If you hit an import error, pip install transformers diffusers huggingface_hub is where to look.

Where people get burned

• First run looks frozen. The model and the T5 encoder download into the HF cache (~/.cache/huggingface), not into ComfyUI/models. Give it time and watch the console.
• Every rerun is slow. The README's own words: the model isn't cached in memory, so each queue reloads the weights. That's the trade for the tiny footprint - patience, not a bug report.
• 512×512 only. That's the architecture; there's no size slider to rescue you.
• Low steps = mush. A 10-step default that produces a rough image isn't a broken install.

MiniT2I won't replace your main checkpoint. It's the node you reach for when you want a whole text-to-image pipeline in one box on modest hardware - and for that job it's refreshingly honest about what it is.