SD Wiki — Veyra Studio

Terms Explained

What the dials and building blocks actually do — not just which value to set.

Basics

Prompt Control

Add-on Models

Resolution and Post-Processing

ComfyUI

SD.Next

ADetailer / Face

ADetailer (After Detailer) is an SD extension that automatically detects faces and hands in generated images and improves them via inpainting. Without ADetailer, anime faces often look blurry or distorted, especially at lower resolutions.

Recommended Models

Settings

Weighting — Control Tags

Weighting lets you control how strongly SD pays attention to specific tags. This is one of the most important tools to control your results.

Syntax

Lighting Tricks

Lighting has a huge impact on the mood and quality of your images. Here are the most important lighting tags and what they do:

Camera / Angle

Camera perspective determines how the viewer perceives the scene. Every angle tells a different story.

Body & Pose

Hands, poses and motion are the hardest aspects for SD. Here are the most important tags and tricks:

Fix Hands

Dynamic Poses

Fabrics / Materials

The right material tags create realistic or stylized fabric textures. Especially for clothing and accessories, these tags make the difference:

Depth / Focus

Depth of field and focus effects create a professional, photographic look and direct the viewer's gaze.

Model Generations: SD 1.5, SDXL, Pony

The most common misconception: Pony is not separate software. Stable Diffusion has versions like an operating system, and almost every model you download is a checkpoint — someone took a base version and trained it further.

That is why Pony, Illustrious and NoobAI all belong to the SDXL family, while Counterfeit, AnythingV5 or Realistic Vision belong to the 1.5 family.

What cannot be mixed

Every program — A1111, Forge, SD.Next, ComfyUI — loads any checkpoint. The software does not care about the generation. The add-ons very much do: LoRAs, ControlNet models, VAEs and embeddings are tied to their generation. An SDXL LoRA will not run on SD 1.5 and vice versa. Downloads always state which base they are made for.

The three most common mistakes

Wrong resolution. SD 1.5 at 832×1216 produces double heads and stretched bodies — the model has never seen such image sizes. 512×768 is correct. Conversely SDXL turns mushy at 512×512.

Foreign vocabulary. score_9, score_8_up is understood only by Pony. On Counterfeit or Illustrious those are dead tokens right at the front of the prompt, where they take up the most room. That is why Veyra sets them per model profile and never inside a style entry.

Forgetting clip skip. Anime models of the 1.5 generation were trained with clip skip 2. In ComfyUI that is a CLIPSetLastLayer node set to −2 between checkpoint and text encoder; it is already wired into Veyra's SD 1.5 workflow template.

Animals, Pokémon and the solo tag

A second living creature in the picture — cat, horse, dragon, Pokémon — behaves differently from an object. Two things are worth knowing, otherwise you get images you cannot explain.

solo means "one character", not "one person"

On Danbooru solo is applied when exactly one character is in the image. A cat is not a character — 1girl, solo, cat is the normal spelling and perfectly fine. A Pokémon is a character: images with Pikachu carry no solo. With both tags in the prompt they pull against each other, and the model either drops the Pokémon or adds a second person. Veyra therefore removes solo automatically as soon as you pick a named creature; for a plain animal it stays.

animal focus only without a figure

animal focus is the tag for an image where the animal is the subject. With a person next to it the animal features migrate onto her — measured on a sleeping cat: the girl got cat ears, a tail and a collar. The tag belongs only in images without a figure, so in background mode. For the same reason an animal entry must not carry an eye colour: green eyes cannot be bound to the cat and ends up on the person.

Riding: the tag decides which animal

horseback riding is the strongest riding tag — and it puts a horse in your image even when you are sitting on a dragon. For anything else riding animal is the right one. The same trap as doggy style, which written as two words produces a dog: a tag that is too specific or ambiguous, at a high weight, beats any description standing next to it.

Backgrounds Without a Character

In the studio you switch between With character and Background only at the top. In the second mode every category that describes a body disappears and a dedicated scene camera appears instead. The reason for a separate mode is not convenience: simply leaving the character out is not enough, as the next section shows.

Why an Empty Prompt Is Not Enough

The Danbooru tag no humans is the clean way to request an empty scene. It belongs near the front of the prompt because early tokens carry more weight, and the person belongs in the negative as well. Important: no humans is a booru tag. It works on Pony, Illustrious, NoobAI and anything trained on booru data. On pure photo checkpoints and on Flux it does not exist in training — there the wording carries it, so empty room, deserted, no people as a sentence. Veyra handles this automatically and writes a full sentence instead of the tag for Flux.

The Trap: Your Style Brings the Character Back

This is where most attempts fail. Location and lighting alone do not put a person in the image — that is measurable. But many style prompts carry body vocabulary: beautiful face, glossy skin, detailed eyes, skin pores. Those tokens bring back exactly the figure that no humans is keeping out. In a test of four runs of the same bedroom, the raw anime style produced a person in all four images — without the style tokens, in none of them. In background mode Veyra strips these tokens from every tag automatically, including style and sharpness. If you prompt by hand, go through your style block and remove anything that describes a body.

What a Character-Free Background Is Good For

An empty image is rarely the final product. The real value lies in what you do with it afterwards.

Choosing a Model

Pony is not the best choice for pure scenery. Its score_ tags come from a dataset that is almost entirely character art — the model is tuned for figures, not for rooms. Illustrious, NoobAI or a landscape checkpoint deliver visibly more detail here. This is the one place where switching models in the studio genuinely pays off.

SD Parameters — Quick Reference

The most important Stable Diffusion settings at a glance. These parameters directly affect the quality and style of your image.

NSFW Anatomy Guide

For NSFW content, SD needs special attention for anatomy and censorship removal. Here are the most important tags and settings:

Stabilize Anatomy

Remove Censorship

These tags must go into the negative prompt, otherwise SD may generate mosaic-like censorship blocks or black bars — especially with Japanese models trained on censored material.

Pony Model NSFW Settings

Body Details

Flux Prompting — Natural Language Instead of Tags

Flux is a fundamentally different model than Pony or Illustrious. Instead of comma-separated Booru tags, Flux understands natural language — complete sentences describing a scene.

What is different?

What Veyra does for Flux

When you select the Flux profile in Veyra, it automatically converts all Booru tags into natural sentences. Score and rating tags are removed since Flux doesn't understand them. You don't need to manually rewrite anything.

Example: Same settings, different format

Forge vs A1111 — Which UI Should You Use?

There are two popular web UIs for Stable Diffusion: the original Automatic1111 (A1111) and the newer Stable Diffusion WebUI Forge. Both look almost identical but have different strengths.

Why does SD struggle with multiple characters?

Stable Diffusion doesn't understand prompts like a human. It reads all tags as a single chain and mixes them in the so-called "Latent Space". For example, if you write:

...SD doesn't think "Person 1 = brown hair, Person 2 = white hair". Instead, it sees only a mix of all tags and creates a single concept. This leads to typical problems:

Faces merge

Both characters suddenly share features: Asuna gets green eyes from Frieren, or a third face appears. SD cannot assign which tags belong to which person.

Positions are displayed incorrectly

For interactions like Face Sitting or 69, SD must understand: Person A is on top, Person B is below. Without help, SD often places both people side by side or in a weird mixed position, because it has no spatial logic.

Bodies merge

Instead of generating two separate bodies, images appear with fused limbs, too many arms/legs, or a "Siamese twin" effect.

What Veyra does automatically for you

When you select 2 or more characters in Veyra, a lot happens behind the scenes to maximize quality:

Anti-Fusion Tags

Veyra automatically adds strong negative tags that prevent SD from fusing the characters:

Character Separation

Tags like two distinct girls, separate bodies are added to the prompt itself, giving SD a stronger hint to generate two separate people.

Yuri Filter (with 2+ Girls)

When you select two female characters, Veyra automatically replaces all male tags: penis becomes strap-on dildo, fellatio becomes cunnilingus, 1boy 1girl is removed and yuri, girl on girl is added.

ADetailer is disabled

With 2+ characters, Veyra disables the ADetailer face prompt because ADetailer doesn't know which face belongs to which character and would otherwise mix up eye colors.

Emotion Override

Default emotions from the character profile (e.g. "unsettling smile") are automatically removed when you select an act type — so nobody smiles inappropriately during an NSFW scene.

Recommended Settings for Multi-Character

Multi-character images need different settings than solo images. Here are the most important adjustments:

Regional Prompter / Forge Couple

The most important extension for multi-character. It divides the image into zones and assigns each zone its own prompt area. This way SD knows exactly: "left = Character A, right = Character B".

Installation

1. For SD WebUI (AUTOMATIC1111):
   Go to Extensions → Install from URL
   URL: https://github.com/hako-mikan/sd-webui-regional-prompter
2. For SD Forge:
   "Forge Couple" is already built into newer versions.
   If not: Extensions → Install from URL
   URL: https://github.com/Haoming02/sd-forge-couple
3. Restart SD. You'll find Regional Prompter / Forge Couple as a new tab in the txt2img area.

Configuration for 2 characters (side by side)

1. Enable Regional Prompter and select the "Columns" mode
2. Set the split to 1:1 (left and right equal size)
3. Separate your prompt with BREAK:
   
   -- Shared Base Prompt (applies to entire image) -- score_9, score_8_up, 2girls, masterpiece BREAK -- Left half: Character 1 -- asuna, brown hair, hazel eyes, smile BREAK -- Right half: Character 2 -- frieren, white hair, green eyes, elf ears
4. Resolution: at least 1024x768 (Landscape)

Configuration for interactions (stacked)

1. Select the "Rows" mode instead of Columns
2. Split 1:1 (top/bottom).
   For Face Sitting e.g. 2:1 (top 2/3, bottom 1/3)
3. score_9, score_8_up, 2girls, yuri, face sitting BREAK -- Upper half: Character sitting on top -- asuna, brown hair, hazel eyes, sitting on face, girl on top BREAK -- Lower half: Character lying below -- frieren, white hair, green eyes, lying down, face between thighs

ControlNet with OpenPose

ControlNet gives SD a skeleton template that shows where each body belongs. This way the model knows exactly: "here stands one body, there lies another".

Installation

1. Install extension:
   Extensions → Install from URL
   URL: https://github.com/Mikubill/sd-webui-controlnet
2. Download OpenPose model:
   Download the model control_v11p_sd15_openpose (or the SDXL/Pony variant) and place it in the models/ControlNet/ folder
3. For Pony/SDXL: Use controlnet_openpose_sdxl or models from https://huggingface.co/thibaud/controlnet-openpose-sdxl-1.0

Create Pose

You need a pose template that shows where the bodies are. Three options:

1. OpenPose Editor (built into SD):
   In the ControlNet tab → "Open Editor". Here you can position stick figures directly. For two people: Create two skeletons and place them as desired.
2. Use a reference image:
   Take a real photo or artwork with the desired pose. ControlNet automatically extracts the skeletons from it (Preprocessor: openpose_full).
3. PoseMaker Website:
   Use online tools like https://webapp.magicposer.com/ to position 3D figures in the desired pose and export as an image.

ControlNet Settings

Latent Couple (Alternative)

Latent Couple is an older extension that works similarly to Regional Prompter, but on a different technical level (Latent Space instead of Attention).

When to use Latent Couple instead of Regional Prompter?

Recommended Workflow Step by Step

This is how to achieve the best multi-character result:

1. Create prompt in Veyra
   Select your characters, act type and style. Veyra generates the optimized prompt with all anti-fusion tags automatically.
2. Copy prompt and paste into SD
   Use the Veyra prompt as a base. Also copy the negative tags.
3. Activate Regional Prompter / Forge Couple
   Split the prompt with BREAK: shared tags on top, then per region the character-specific tags (hair, eyes, face, body). Act/interaction tags go in the shared part.
4. Optional: Create ControlNet pose
   For complex positions (69, Face Sitting, etc.) create an OpenPose template or use a reference image. Set Control Weight to 0.7 – 0.9.
5. Adjust settings
   High resolution (min. 768x768), CFG 7–9, Steps 28–40, DPM++ 2M Karras.
6. Generate batch and select
   Generate 4–8 images at once. Multi-character has a lower hit rate — that's normal. Pick the best result.
7. Refine with img2img / Inpainting
   If an image is 80% good but one detail is wrong (e.g. eye color of one person): Use Inpainting to regenerate only that area. Denoise: 0.3–0.5.

Which Model for Multi-Character?

LoRA — Add-on Models for Characters, Styles and Concepts

What is a LoRA?

LoRA stands for Low-Rank Adaptation. It is a small add-on model (10–200 MB) that is placed on top of a base model (checkpoint). Think of it this way: the checkpoint is the brain, and the LoRA is a specialized lens that teaches the model to correctly render a specific character, art style, or concept. A LoRA does not modify the base model — it only extends its knowledge.

When do I need a LoRA?

Whenever the base model doesn't know something or can't render it well enough:

• New/niche characters — e.g. Emma from Pokémon Legends Z-A, which is too new for most model training data
• Specific art styles — e.g. Pokémon style, Ghibli look, or a particular manga drawing style
• Outfits and concepts — e.g. mecha armor, fantasy weapons, or specific clothing items
• Poses and compositions — e.g. dynamic fighting poses or specific camera angles

How do I install a LoRA?

Download the .safetensors file from CivitAI and place it in the correct folder. In the prompt, activate the LoRA with a special tag:

Choosing the Right Strength

The number after the filename determines how strongly the LoRA takes effect. Too low = barely any effect, too high = artifacts and exaggerated features.

Types of LoRAs

Combining Multiple LoRAs

You can use multiple LoRAs simultaneously — e.g. a character LoRA + a style LoRA. Reduce the strength of both LoRAs slightly (e.g. 0.5–0.7 each) so they don't interfere with each other.

Important Tips

Where do I find LoRAs?

The largest collection can be found on CivitAI. There you can search by character, style, or concept and directly download the .safetensors file. Pay attention to ratings, sample images, and the compatible base model specification (SDXL, Pony, Illustrious, Flux).

Common Mistakes and Solutions

Both characters look the same

Cause: SD mixes the features of both characters together.
Solution: Use Regional Prompter to separate tags spatially. Ensure same face, cloned face, identical faces is in the negative prompt (Veyra does this automatically).

Three or more faces instead of two

Cause: Too low resolution or too generic tags.
Solution: Use at least 768x768 resolution. In negative: extra faces, extra head, third person. Fewer tags = less confusion for SD.

Limbs merge / extra arms

Cause: SD doesn't know where one body ends and another begins.
Solution: Use ControlNet with OpenPose. The skeleton template defines exactly which limbs are where. In negative: extra limbs, fused limbs, conjoined.

Position is ignored

Cause: SD doesn't follow the pose description strongly enough.
Solution: Increase CFG Scale (8–10). Give position tags higher weight: (face sitting:1.4). Best to use ControlNet with a matching pose template.

Character features swap

Cause: Without Regional Prompter, SD has no mechanism to assign tags.
Solution: Regional Prompter / Forge Couple is the only reliable solution here. Optional: Use Inpainting to correct the wrong hair color.

Image gets "panelized"

Cause: Tags like side by side or split screen can make SD split the image into panels.
Solution: Veyra removes side by side automatically when an act type is selected. In negative prompt: split screen, comic panels, manga panels, border, frame.

Pro Tips

Install Stable Diffusion

Step-by-step guide for Windows, macOS, and Linux. Stable Diffusion runs locally on your PC — no cloud, no subscription costs, no censorship.

Prerequisites: Python & Git

Stable Diffusion Forge (Recommended)

Forge is a fork of A1111 with better memory optimization, faster generation, and native Flux support. The best choice for most users.

git clone https://github.com/lllyasviel/stable-diffusion-webui-forge
cd stable-diffusion-webui-forge
webui-user.bat

git clone https://github.com/lllyasviel/stable-diffusion-webui-forge
cd stable-diffusion-webui-forge
./webui.sh --skip-torch-cuda-test --no-half --use-cpu interrogate

git clone https://github.com/lllyasviel/stable-diffusion-webui-forge
cd stable-diffusion-webui-forge
bash webui.sh

GitHub Repository

AUTOMATIC1111 Web UI

The original frontend for Stable Diffusion. Largest extension ecosystem, most tutorials available. Slightly slower than Forge, but very stable.

git clone https://github.com/AUTOMATIC1111/stable-diffusion-webui
cd stable-diffusion-webui
webui-user.bat

git clone https://github.com/AUTOMATIC1111/stable-diffusion-webui
cd stable-diffusion-webui
./webui.sh --skip-torch-cuda-test --no-half --use-cpu interrogate

git clone https://github.com/AUTOMATIC1111/stable-diffusion-webui
cd stable-diffusion-webui
bash webui.sh

GitHub Repository

ComfyUI (Node-based)

Node-based interface for advanced users. Maximum control over every step of the pipeline. Steep learning curve, but extremely powerful.

git clone https://github.com/comfyanonymous/ComfyUI
cd ComfyUI
pip install -r requirements.txt
python main.py

git clone https://github.com/comfyanonymous/ComfyUI
cd ComfyUI
pip install -r requirements.txt
python main.py --force-fp16

GitHub Repository

Download Models & Checkpoints

Without a checkpoint model, SD cannot generate images. Find the best anime models on CivitAI. Recommended: Pony Diffusion V6 XL, Illustrious XL, NoobAI XL.

# Forge / A1111:
models/Stable-diffusion/    ← Checkpoints (.safetensors)
models/Lora/                ← LoRA Modelle
models/VAE/                 ← VAE Dateien

# ComfyUI:
models/checkpoints/         ← Checkpoints
models/loras/               ← LoRA Modelle
models/vae/                 ← VAE Dateien

Notes for macOS (Apple Silicon)

Troubleshooting

What is ComfyUI?

ComfyUI is a node-based interface for Stable Diffusion. Instead of a classic form, you see the entire image generation pipeline as a graph of connected nodes — loading the model, text encoding, sampling, VAE decode, saving. Every step is visible and adjustable.

The advantage: full control over the workflow, reproducible setups (shareable as JSON), very efficient VRAM usage, and native support for all current models (SDXL, Flux, SD3, video models). The downside: steeper learning curve than A1111/Forge.

System Requirements

The critical component is video memory (VRAM). It determines which models you can even load and how fast generation runs.

Additionally: at least 16 GB RAM (32 GB recommended for SDXL/Flux), an NVMe SSD for fast model loading, and a PSU that handles GPU load (for RTX 4090: 850W+ Gold).

Prerequisites

ComfyUI runs on Python and is downloaded via Git. First install Python 3.10 or 3.11 and Git for your operating system.

Installation

Two paths are available: a prepackaged portable version for Windows (no setup required) or manual installation from source (works on all systems and is better maintainable).

Windows Portable Version (recommended for beginners)

A single 7z archive with prebuilt Python and all dependencies. Extract, drop in models, double-click run_nvidia_gpu.bat. No Python knowledge needed.

Download Portable Version from GitHub Releases

Manual Installation (recommended for advanced users)

Clones the repository, sets up an isolated Python environment (venv) and installs PyTorch with the matching GPU backend. Advantage: easier to update with git pull, no 15 GB duplicated on disk.

git clone https://github.com/comfyanonymous/ComfyUI.git
cd ComfyUI
python -m venv venv
.\venv\Scripts\activate
pip install torch torchvision torchaudio --extra-index-url https://download.pytorch.org/whl/cu121
pip install -r requirements.txt
python main.py

git clone https://github.com/comfyanonymous/ComfyUI.git
cd ComfyUI
python3 -m venv venv
source venv/bin/activate
pip install torch torchvision torchaudio
pip install -r requirements.txt
python main.py --force-fp16

git clone https://github.com/comfyanonymous/ComfyUI.git
cd ComfyUI
python3 -m venv venv
source venv/bin/activate
pip install torch torchvision torchaudio --extra-index-url https://download.pytorch.org/whl/cu121
pip install -r requirements.txt
python main.py

pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/rocm6.0

After launching, the UI runs at http://127.0.0.1:8188. Open the address in your browser.

GitHub Repository

Launch Parameter Reference

These parameters are appended to python main.py. They control VRAM usage, precision, network access, and multi-GPU behavior.

Example Startup Script

Instead of typing the command line every time, put your parameters into a startup script. It activates the venv, starts ComfyUI with your parameters, and can be launched by double-click or terminal.

@echo off
call .\venv\Scripts\activate
python main.py --fast --highvram --port 8188
pause

#!/bin/bash
cd "$(dirname "$0")"
source venv/bin/activate
python main.py --fast --highvram --port 8188

ComfyUI Manager (Custom Nodes)

ComfyUI is minimal out of the box. The real power comes from custom nodes — extensions that add new capabilities (ControlNet, face-fix, video, upscalers, IP-Adapter, LoRA loaders, and many more).

The ComfyUI Manager is the central hub for these: it shows available custom nodes, installs them with one click, updates existing ones, and disables broken ones. Install manually via Git clone into the custom_nodes folder:

cd ComfyUI\custom_nodes
git clone https://github.com/ltdrdata/ComfyUI-Manager.git

cd ComfyUI/custom_nodes
git clone https://github.com/ltdrdata/ComfyUI-Manager.git

Restart ComfyUI. A new Manager button appears in the top right — there you'll find "Install Custom Nodes" for easy click-installation.

Recommended Custom Nodes for Veyra Prompts

• ComfyUI-ControlNet-Aux — pose and depth preprocessing for ControlNet.
• ComfyUI Impact Pack — face detection and face-fix (alternative to A1111's ADetailer).
• Efficiency Nodes — bundles several standard nodes into one, saves workspace.
• rgthree-comfy — quality-of-life nodes for clean workflows (muter, bookmarks, progress bar).
• WAS Node Suite — huge collection of utility nodes (text, image operations, logic).

GitHub Repository

Share Models with A1111/Forge

If you already have an A1111 or Forge installation with many models, you don't want them duplicated on disk. ComfyUI can read external model paths via extra_model_paths.yaml and use existing models directly.

# Windows / macOS / Linux — im ComfyUI-Ordner:
cp extra_model_paths.yaml.example extra_model_paths.yaml

a111:
    base_path: D:/AI/stable-diffusion-webui
    checkpoints: models/Stable-diffusion
    vae: models/VAE
    loras: models/Lora
    controlnet: models/ControlNet
    embeddings: embeddings
    upscale_models: models/ESRGAN

Mapping Veyra Prompt to ComfyUI Nodes

A Veyra prompt consists of multiple components (model profile, positive prompt, negative prompt, LoRA). This table shows which component goes into which ComfyUI node.

Loading a Veyra Workflow in ComfyUI

Veyra can generate a ready-made ComfyUI template with your prompt already filled in. Download it, drop it into ComfyUI and hit run — no retyping, no wiring nodes together.

Step 1 — Download

In the studio click Workflow, next to the copy button above the positive prompt. You get a JSON file such as veyra_bild_2026-09-06.json. Pro and Lifetime users get it with the prompt filled in, everyone else gets the empty template.

Step 2 — Open it in ComfyUI

Three ways, all equivalent — the first is the fastest.

• Drag the JSON file from your downloads folder into the ComfyUI window. The graph builds itself immediately.
• Use the menu: Workflow → Open (older builds: Load) and pick the file.
• Keyboard shortcut Ctrl+O, or Cmd+O on a Mac.

Step 3 — The one field you must set

Top left, in the node 1 — Modell wählen, you will see HIER_DEIN_MODELL.safetensors. Click it and pick your checkpoint. Veyra cannot know what your model files are called — this is the only step left to you. Make sure the model matches the prompt family: a Pony prompt needs a Pony model.

Step 4 — Run

Press Run or Queue Prompt. The result lands in ComfyUI/output/veyra/.

What the nodes do

The six templates

In the studio the download sits behind the Workflow button. Every template runs on a stock ComfyUI — no custom nodes to install.

The upscale template needs an extra file

Five of the six templates run in a freshly installed ComfyUI. The sixth does not: UpscaleModelLoader and ImageUpscaleWithModel are core nodes, but ComfyUI does not ship the model file. Put it into ComfyUI/models/upscale_models/ and restart ComfyUI. For anime pick RealESRGAN_x4plus_anime_6B (about 18 MB), for hard detail and photos 4x-UltraSharp (about 67 MB). The template upscales 4x and then scales back to half — 2x net, with cleaner edges than going straight to 2x. For the full 4x, delete the downscale node. Both are saved, the original and the enlarged version.

Inpainting: the mask

This is the one step no template can do for you. Load the background in the Load Image node, then right-click it and choose Open in MaskEditor. Paint the area where the figure should stand, then save.

• The size and ground point of the mask have to match the background's horizon line. If that is wrong, no slider fixes it afterwards.
• Leave denoise at 1.0 — the masked area is generated from scratch.
• grow_mask_by expands the mask outwards. Below 8 the seam often shows.
• The background should already be at your target resolution — the pass runs at the loaded image's size.

Understanding denoise

The denoise value in the KSampler is the key slider in every multi-stage template. It says how much of the existing image gets overwritten.

Anime or ultra-realistic

The templates for Pony, Illustrious and SDXL are set up for anime: clip skip 2, CFG 7.0, dpmpp_2m, 28 steps. The WAI Illustrious and NoobAI XL profiles get their own template — 1024×1344, euler_ancestral, CFG 5.5, 24 steps, hires fix already built in. Those values come from the model cards, so do not change them there. For photorealism set clip skip to 1, CFG to 5.5, the sampler to dpmpp_2m_sde and steps to 32 — those four values are also written on each template's note. The checkpoint itself matters far more though: CFG 5.5 will not turn an anime model photorealistic.

NoobAI: eps-pred or v-pred?

NoobAI XL comes in two flavours, and they need different settings. The eps-pred version runs with the template as it is. The v-pred version (also WAI-SHUFFLE-NOOB) additionally needs a ModelSamplingDiscrete node set to v_prediction, placed between checkpoint and KSampler, plus a much lower CFG of 3 to 5. Without that node v-pred produces washed out or blown out images. The file name or the model page tells you which one you have.

When something does not work

Troubleshooting

What is SD.Next?

SD.Next (vladmandic/sdnext) is a modernized fork of AUTOMATIC1111. It keeps the familiar Gradio interface but brings significantly faster backend, more current model support (SDXL, Flux, SD3, Cascade), and an optional "Modern UI".

The advantage over A1111: aggressive development, native Diffusers pipeline (better Flux performance), modern optimizations. The advantage over ComfyUI: classic form UI, no node wiring needed, faster onboarding.

System requirements: identical to ComfyUI (see the VRAM table in the ComfyUI section above).

Installation

SD.Next largely installs itself: clone the repository, run the startup script — everything else (venv, PyTorch, requirements) is handled by the script on first launch.

Prerequisites: Python 3.10 or 3.11 and Git (see the prerequisites table in the ComfyUI section above — identical for both UIs).

git clone https://github.com/vladmandic/sdnext.git
cd sdnext
webui.bat

git clone https://github.com/vladmandic/sdnext.git
cd sdnext
./webui.sh --use-mps

git clone https://github.com/vladmandic/sdnext.git
cd sdnext
./webui.sh

First launch takes 5–15 minutes (PyTorch download, requirements installation). Afterward the UI runs at http://127.0.0.1:7860.

GitHub Repository

Launch Parameter Reference

Unlike ComfyUI, you set parameters via the COMMANDLINE_ARGS environment variable in webui-user.bat (Windows) or webui-user.sh (macOS/Linux).

set COMMANDLINE_ARGS=--medvram --xformers --port 7860

export COMMANDLINE_ARGS="--medvram --port 7860"

Precision: FP16, FP32 and xformers

These three concepts determine how SD.Next calculates the numbers in the neural network. Wrongly chosen means: slow generation, high VRAM usage, or black images.

FP16 (Half-Precision)

16 bits per number. Halves memory usage and is usually faster on modern GPUs (RTX 20xx and newer). Default for most setups. Mandatory on Apple Silicon.

FP32 (Full-Precision)

32 bits per number. Doubled VRAM usage, slower, but mathematically more stable. Needed on very old NVIDIA cards (GTX 10xx and older) that don't cleanly support FP16. Enabled with --no-half or --precision full.

xformers

Library that optimizes the attention mechanism (the most VRAM-hungry part). Enabled with --xformers. Almost always useful on older GPUs (RTX 20xx/30xx, GTX 16xx). On RTX 40xx often slower than PyTorch's native SDPA optimization — test.

Installing Extensions

Extensions add features to SD.Next (ADetailer for face-fix, ControlNet for pose/depth control, Regional Prompter for multi-character, upscalers, and many more). Two paths available: via UI or directly via terminal.

Path 1: Via UI

In the tab Extensions → Available, load the list, click desired extension, press "Install", then tab Installed → "Apply and restart UI".

Path 2: Via Terminal

cd sdnext\extensions
git clone https://github.com/Bing-su/adetailer.git
git clone https://github.com/Mikubill/sd-webui-controlnet.git

cd sdnext/extensions
git clone https://github.com/Bing-su/adetailer.git
git clone https://github.com/Mikubill/sd-webui-controlnet.git

After cloning, restart SD.Next. The extension appears automatically in the Installed tab.

Recommended Extensions for Veyra Prompts

• ADetailer — Automatically processes the ADetailer face prompt from Veyra Pro. Fixes faces in full-body portraits.
• ControlNet — Geometric control over pose, depth, and edges. Perfect for precise multi-character scenes.
• Regional Prompter — Assigns prompt parts to specific image regions. Core piece for clean multi-character images.
• Ultimate Upscale — Upscale to 4k+ without VRAM explosion via tile-based rendering.

Using Veyra Prompt in SD.Next

A Veyra-generated prompt can be used directly in SD.Next. Here's the workflow:

1. Generate the prompt in Veyra Studio and copy it (Copy button next to the result).
2. In SD.Next, open the Text2Image tab and paste the prompt into the top text field.
3. Copy the Negative Prompt from Veyra and paste it into the Negative text field below.
4. Select checkpoint (model) top left — the one matching the Veyra model profile (Pony, Illustrious, Flux, SDXL, SD 1.5).
5. Set sampler + steps according to Veyra's recommendation. Resolution: SDXL 1024×1024 or 832×1216, SD 1.5 512×768.

Troubleshooting