Lumina T2I Sampler

This is where Lumina actually makes the image. Everything before - loading the 2B model, loading Gemma, encoding your prompt - is setup. LuminaT2ISampler is the node that turns noise into a latent over a flow-matching ODE solve, then hands you a LATENT you decode with a normal SDXL VAE.

If you're used to a KSampler, the shape is familiar but the knobs are different. The headline difference: Lumina uses an ODE-based flow-matching sampler, and the pack gives you a real solver choice (euler / midpoint / rk4) plus a t_shift knob for the time schedule. Flow matching means noise doesn't fade over "steps" the way diffusion does - the model learns to push the image from pure noise toward data along a learned path, and the solver is doing numeric integration along that path.

How it works, in brief

The node takes your empty latent, scales it by the SDXL VAE scaling factor (0.13025), seeds noise, and runs the model's forward_with_cfg - note that CFG is computed inside the model call, which is why your n_prompt from the encode node still matters here. Then it solves the ODE with the chosen solver over steps timesteps. It's a genuine sampler: euler is fast and rough, midpoint (default) is the quality/effort sweet spot, rk4 is the most accurate and slowest - twice the model calls, since it's a higher-order integrator.

The inputs that matter

• lumina_model / lumina_embeds - from the two loaders and the encode node. Wire them right or nothing runs.
• latent - an empty latent from Empty Latent Image, sized in pixels (the sampler multiplies by 8, so 1024×1024 on the empty-latent node gives you a 1024×1024 image). For img2img, feed an encoded image latent instead and lower strength.
• steps (25) / cfg (4) - sensible defaults, and honestly they hold up. Flow-matching wants CFG around 3-5, not SDXL's 7.
• seed - plain integer, use a random one unless you're reproducing a result.
• solver - euler / midpoint / rk4. Start at midpoint.
• t_shift (4) - shifts the ODE time schedule toward the data end. This is Lumina's version of a noise schedule choice; 4 is the default for a reason, and you only need to touch it if you're chasing specific behavior at high resolution.
• strength (1.0) - your img2img lever. At 1.0 it's full denoise; lower it to keep more of the source latent.
• The niche pair: proportional_attn (for non-square aspect ratios, off by default) and do_extrapolation with scaling_watershed - the latter enables RoPE extrapolation so you can push past the training resolution (1024) with less quality collapse. Turn on do_extrapolation for big images; leave both off otherwise.

Output: samples, a LATENT. Decode it with a plain VAEDecode using an SDXL VAE (sdxl_vae.safetensors - the pack's example workflows use exactly that). That trips people up: Lumina's VAE is the SDXL VAE, so any SDXL VAE file works and there's no separate download.

Installing and the honest take

Pack install: ComfyUI Manager (search "ComfyUI-LuminaWrapper"), or git clone https://github.com/kijai/ComfyUI-LuminaWrapper into custom_nodes, pip install -r requirements.txt (the torchdiffeq dependency is what powers the ODE solving), restart.

Two things to know. First, flash_attn is not optional if you care about speed - without it the attention falls back to torch SDP at "at least twice as slow and memory hungry" per the README, and this sampler is already the slow node in the graph. Windows: prebuilt wheel from the bdashore3 flash-attention releases. Second, manage expectations: Lumina-Next is an artistic, synthetic-data-trained model. It's great for painterly, composition-driven stuff (especially with the area nodes) and mediocre at clean photorealism and humans. It's a change-of-pace model you reach for deliberately - but when you do, the sampler is the node you'll tune most, so it's worth understanding the few knobs that actually matter.