Save 4 hours! We auto-setup your workflow! Free!

Drop your workflow.json — we handle every dependency, custom node, and model. Just open the link and run.

Auto-Setup Workflow Json (Free) Now!
ComfyUI > Nodes > ComfyUI-Neo-Sampler

ComfyUI Extension: ComfyUI-Neo-Sampler

Repo Name

ComfyUI-Neo-Sampler

Author
wangjue520 (Account age: 0 days)
Nodes
View all nodes(1)
Latest Updated
2026-11-03
Github Stars
0.0K

How to Install ComfyUI-Neo-Sampler

Install this extension via the ComfyUI Manager by searching for ComfyUI-Neo-Sampler
  • 1. Click the Manager button in the main menu
  • 2. Select Custom Nodes Manager button
  • 3. Enter ComfyUI-Neo-Sampler in the search bar
After installation, click the Restart button to restart ComfyUI. Then, manually refresh your browser to clear the cache and access the updated list of nodes.

Visit ComfyUI Online for ready-to-use ComfyUI environment

  • Free trial available
  • 16GB VRAM to 80GB VRAM GPU machines
  • 400+ preloaded models/nodes
  • Freedom to upload custom models/nodes
  • 200+ ready-to-run workflows
  • 100% private workspace with up to 200GB storage
  • Dedicated Support

Run ComfyUI Online

ComfyUI-Neo-Sampler Description

ComfyUI-Neo-Sampler brings SD WebUI Forge Neo sampling to ComfyUI, matching prompt encoding, starting noise, samplers, and schedulers to help reproduce Neo images with the same settings and model.

ComfyUI-Neo-Sampler Introduction

ComfyUI-Neo-Sampler brings the sampling workflow of SD WebUI Forge Neo into ComfyUI. It is based on the Neo branch at commit 41359cd (September 18, 2026). Its purpose is to help you reproduce a Neo image in ComfyUI using the same seed, prompts, sampling settings, and model, while keeping the flexibility of a ComfyUI node workflow.

The extension provides three core nodes:

  • Neo CLIP Converter applies Neo’s prompt-encoding rules to compatible text-encoding nodes.
  • Neo Empty Latent creates the starting noise using Neo’s random-number rules and preserves the state needed by later passes.
  • Neo KSampler runs Neo’s samplers, schedulers, and sampling logic.

It also provides nodes for prompt-based LoRAs, Turbo LoRAs, and the upscale stage of Hires.fix. These are useful when you are moving an existing Neo workflow into ComfyUI or trying to understand why two workflows with apparently identical settings produce different images.

The author tested the sampling pipeline against Neo reference code across 594 CPU-based combinations and reported bit-identical results for those tests. An exact match is not guaranteed on every computer: GPU operations, PyTorch versions, and attention implementations can introduce small numerical differences.

How ComfyUI-Neo-Sampler Works

Image generation begins with noise. Think of the seed as an instruction for preparing the same starting canvas each time: if the noise source and other settings also match, you can repeat the same starting conditions. Neo Empty Latent creates that noise according to Neo’s rules. It supports CPU, GPU, and NV noise sources, variation seeds, and the seed changes used for images in a batch.

Your prompt then needs to be interpreted. Neo CLIP Converter sits between your CLIP output and your text-encoding nodes so supported encoders interpret emphasis and other prompt details as Neo does. Finally, Neo KSampler gradually turns the noise into an image. A sampler determines how that process proceeds; a scheduler determines how its steps are distributed.

A basic workflow looks like this:

UNET or checkpoint ─→ optional LoRA ───────────────────────→ Neo KSampler.model

CLIP ─→ optional LoRA ─→ Neo CLIP Converter
                         ├─→ positive text encode ────────→ Neo KSampler.positive
                         └─→ negative text encode ────────→ Neo KSampler.negative

Neo Empty Latent ──────────────────────────────────────────→ Neo KSampler.latent_image

For Hires.fix, generate the first image with a Neo KSampler, upscale its latent with a latent-upscale node or Neo Hires Upscale, and send the result to a second Neo KSampler. Set the second sampler to Hires.fix mode and set denoise to your redraw strength. This second pass reuses the first pass’s seed and creates noise at the new size.

For image-to-image, connect VAE Encode to Neo Empty Latent’s latent input, then connect Neo Empty Latent to Neo KSampler. Image-to-image starts from an encoded image rather than a blank canvas, so the denoise setting affects how strongly the image is redrawn.

ComfyUI-Neo-Sampler Features

Core Nodes and Matching Settings

NodeWhat you can controlWhy it matters
Neo CLIP Converteremphasis, clip_skip, and anima_te_precisionThese correspond to Neo’s emphasis mode, Clip Skip, and Anima text-encoder precision. Neo’s Anima text-encoder default is fp16.
Neo Empty Latentrng_source, eta_noise_seed_delta, subseed, and subseed_strengthThese correspond to Neo’s RNG source, ENSD, variation seed, and variation strength. Neo’s factory-default RNG source is CPU; check your actual Neo setting when matching a result.
Neo KSamplerSampler, scheduler, shift, and additional sampler parametersThe extension offers 21 samplers and 17 schedulers, listed in Neo’s dropdown order. Its optional sampler parameters correspond to Neo’s “Settings → Sampler parameters” entries and use the same defaults. Setting shift to 0 uses the model’s built-in value, which is 3.0 for Anima.

When comparing outputs, keep the seed, RNG source, prompts, model, sampler, scheduler, and relevant optional settings consistent. Changing just one of these can change the image.

Prompt Timing and Emphasis

Neo KSampler supports Neo prompt syntax, including:

  • [a:b:steps] to change prompt content during generation.
  • [a|b] to alternate prompt content.
  • AND to combine prompt parts with weights.
  • BREAK to separate prompt chunks.
  • (x:1.2) to strengthen a prompt element and [x] to reduce its emphasis.

These controls let you do more than describe a static scene. For example, you can change which idea is emphasized as sampling progresses. The extension also follows Neo’s rules for per-step prompt changes, AND weights, second-order samplers, and the Hires.fix pass. At CFG 1, it follows Neo’s behavior of ignoring the negative prompt.

Important: A text-encoding node must use clip.tokenize and clip.encode_from_tokens for the original prompt text to reach Neo KSampler. If it does not, ordinary conditioning can still be sampled, but Neo’s prompt scheduling and AND behavior will not work through that node.

Prompt LoRAs

With prompt_lora enabled, Neo KSampler reads LoRA tags from the positive prompt. Supported forms include:

<lora:name:weight>
<lora:name:TE weight:UNet weight>

Named te= and unet= weights are also supported. The text-encoder weight and model weight let you control those two effects separately. LoRAs are applied in the order written. Although tags are read only from the positive prompt, the LoRA-adjusted text encoder is also used to encode the negative prompt.

The extension looks for a LoRA by filename without its extension, including files in subfolders, and then by its internal ss_output_name alias. If it cannot find a LoRA, it skips that LoRA and reports the problem in the console.

Avoid applying the same LoRA twice. If you use a separate LoRA Loader or Neo Prompt LoRA, turn off Neo KSampler’s prompt_lora option.

Additional Nodes

NodeWhen to use it
Neo Prompt LoRAUse this when you want LoRAs written in the positive prompt to be applied to the MODEL and CLIP outputs before downstream nodes use them. This allows downstream nodes, including inpainting nodes, to receive those LoRAs. Turn off the sampler’s prompt_lora option.
Neo Turbo BoostUse this to load a Turbo LoRA onto the model and send few-step, low-CFG settings to Neo KSampler through its turbo output. If the whole group is bypassed, the model passes through unchanged and the sampler uses its own settings again.
Neo Hires UpscaleUse this between two Neo KSamplers to reproduce Neo’s Hires.fix upscale stage. It rounds the target size to a Resolution Step of 64 by default. You can choose latent interpolation or an upscale-model path that uses Lanczos resizing and VAE encoding. Connect its output to a second Neo KSampler in Hires.fix mode.

Out-of-Memory Recovery

If an operation actually runs out of VRAM, the extension can retry with smaller pieces:

  • VAE work: ComfyUI handles this.
  • Upscale-model work: The tile size is halved on retry.
  • Neo KSampler: Sampling switches to overlapping 1024-pixel tiles and can halve the tile size further if needed.

This fallback is triggered by an out-of-memory error, not during normal sampling. Tiled recovery helps a workflow finish, but the readme’s normal-operation equivalence claim should not be taken as a guarantee that a tiled retry produces a bit-identical image.

ComfyUI-Neo-Sampler Models

The extension does not provide downloadable image models. Its Neo-style text encoding explicitly supports these model families:

  • Anima: Uses Neo’s Anima text-processing rules, including its T5 token handling and attention-mask behavior. The Anima text encoder’s precision can be set in Neo CLIP Converter. For Anima, shift=0 uses the model’s built-in value of 3.0.
  • SD 1.5: Uses Neo-compatible prompt chunking, emphasis, and Clip Skip behavior. Choose this path when matching an SD 1.5 workflow in Neo.
  • SDXL: Uses Neo-compatible handling of SDXL’s text-encoder outputs, alongside its prompt chunking and emphasis rules. Choose this path when matching an SDXL workflow in Neo.

Other models’ CLIP encoders fall back to ComfyUI’s native encoding, with a console notice. In that case, do not assume the prompt encoding will match Neo. The sampling tests also covered both flow and eps model types, but the source does not provide a complete list of supported checkpoints or model-specific recommendations.

Troubleshooting ComfyUI-Neo-Sampler

My image does not match the one I made in Neo

  1. Confirm that you are using the same checkpoint or model, prompts, seed, sampler, scheduler, step count, and other relevant sampling settings.
  2. Check Neo Empty Latent’s rng_source against the RNG setting in Neo. Neo’s factory default is CPU, but your saved setting may differ.
  3. Check ENSD, variation seed and strength, shift, Clip Skip, emphasis mode, and any optional sampler parameters.
  4. Confirm that both positive and negative text encoders receive CLIP through Neo CLIP Converter.
  5. Check whether a LoRA has been applied twice: turn off prompt_lora when using a LoRA Loader or Neo Prompt LoRA.
  6. If the settings match but pixels still differ slightly, consider GPU operations, PyTorch versions, and attention implementations. These can cause small numerical differences.

Prompt scheduling or AND does not seem to work

  1. Check that the text encode node receives its CLIP input from Neo CLIP Converter.
  2. Check whether that text encode node uses clip.tokenize and clip.encode_from_tokens. Nodes that bypass these methods cannot pass the raw prompt text to Neo KSampler.
  3. Test the prompt with a compatible text encode node to determine whether the issue is specific to the node you were using.

A prompt LoRA has no effect, or its effect is too strong

  1. Make sure the <lora:…> tag is in the positive prompt.
  2. Check the LoRA name against its filename or internal alias; look in the console for a missing-LoRA error.
  3. If the effect is too strong, check for duplicate loading through prompt_lora, Neo Prompt LoRA, or another LoRA Loader.
  4. Adjust the LoRA weight, or use separate text-encoder and UNet weights if you need finer control.

Hires.fix or image-to-image behaves unexpectedly

  1. For Hires.fix, connect the first Neo KSampler → upscale node → second Neo KSampler.
  2. Set the second Neo KSampler to Hires.fix mode and set denoise to the intended redraw strength.
  3. For image-to-image, connect VAE Encode → Neo Empty Latent’s latent input → Neo KSampler.
  4. Check which step-count behavior you intend: Hires.fix uses its specified step count, while the other image-to-image behavior uses steps multiplied by denoise.

I run out of VRAM

  1. Check whether the console reports an actual out-of-memory error; that is what triggers the automatic tile retries.
  2. Allow the retry to run. The upscale model can retry with a smaller tile, and Neo KSampler can retry with overlapping tiled sampling.
  3. If the workflow still cannot complete, reduce the image size or other memory demands in your workflow. A tiled retry cannot guarantee that every workload will fit.

Frequently Asked Questions

Does every ComfyUI node use Neo’s sampling behavior?
No. Neo KSampler uses Neo’s sampling logic, but another node that invokes ComfyUI’s own sampler internally, such as an Impact face detailer, does not automatically use it.

Can I use other model additions such as ControlNet?
Neo KSampler still runs the model through ComfyUI’s execution path, so model patches such as LoRA, ControlNet, and RescaleCFG can take effect.

Are inpainting masks supported?
Inpaint noise masks (noise_mask) are not currently supported. Textual Inversion embeddings and Refiner are also listed as unsupported.

Why might Anima differ even when my settings match?
Besides general GPU and attention differences, Anima’s LLM adapter runs at the diffusion model’s precision in ComfyUI, usually bf16, while Neo uses fp16.

Are the author’s comparison results a guarantee for my setup?
No. The author reports bit-identical CPU comparisons for 594 tested sampling combinations, bit-identical scheduler outputs, and matching CPU and NV RNG results. Hardware and software differences can still affect an end-to-end image.

Learn More about ComfyUI-Neo-Sampler

For the exact settings this extension aims to reproduce, compare your workflow with SD WebUI Forge Neo’s RNG, prompt, Hires.fix, and “Settings → Sampler parameters” options. The extension is based on the Neo branch at commit 41359cd, so that reference is more precise than assuming every later Neo change is included here.

For the terms used in this readme, the relevant ComfyUI concepts are CLIP text encoding, latents, VAE encoding, LoRA, and KSampler. Understanding how those nodes connect will make it easier to adapt an existing workflow while keeping its Neo-specific settings consistent.

The extension includes code ported from Forge Neo and is licensed under AGPL-3.0; see its LICENSE file for the license terms.

ComfyUI-Neo-Sampler Related Nodes

RunComfy
Copyright 2025 RunComfy. All Rights Reserved.

RunComfy is the premier ComfyUI platform, offering ComfyUI online environment and services, along with ComfyUI workflows featuring stunning visuals. RunComfy also provides AI Models, enabling artists to harness the latest AI tools to create incredible art.

ComfyUI-Neo-Sampler detailed guide | ComfyUI