How to Keep Characters Consistent in NSFW AI Videos

What Are ID Lock Tools?

Tools like InstantID, PuLID, and PhotoMaker are plugins for AI image models. You feed them a single face photo, and they extract the key facial features — the distance between the eyes, the shape of the jaw, the nose bridge angle. Then, when generating new images, they use these features as an anchor to keep the face consistent.

The term "zero-shot" means you don't need to train anything. Upload one photo, and the tool works immediately. No waiting, no GPU hours, no dataset preparation.

How They Compare

How to Use It (Step-by-Step in ComfyUI)

Step 1: Install the Node

1. Open ComfyUI. If you're using ComfyUI V1 / Desktop, click the Plugin / Extensions icon in the top-right corner (or go to Menu → Help → Extension Management). On older versions, click the Manager button in the menu bar → Custom Nodes Manager.
2. In the search box, type "ComfyUI_InstantID" (for InstantID) or "PuLID_ComfyUI" (for PuLID). Click Install next to the result by "cubiq". Wait for it to finish, then click Restart.
3. After ComfyUI restarts, refresh your browser. The new nodes are now available.

Step 2: Download the Required Models

The nodes need several model files to work. Here's where each one goes:

Step 3: Build the Workflow

The easiest way: go to the GitHub page for InstantID or PuLID, find the examples/ folder, download a sample workflow .json file, and drag it into your ComfyUI browser window. It will load a pre-built workflow with all nodes already connected. Then just:

1. Select your SDXL checkpoint in the "Load Checkpoint" node
2. Load your reference face photo into the "Load Image" node
3. Write your prompt in the "Positive Prompt" box — describe what you want (e.g., "beautiful woman, side profile, wearing elegant black dress, studio lighting")
4. Set CFG to 4-5 (important! — InstantID works poorly at the default CFG of 7-8, images will look burned/over-contrasted)
5. Use a resolution like 1016x1016 instead of 1024x1024 — this avoids watermarks from the training data
6. Click Queue Prompt (or press Ctrl+Enter) to generate

Tips for Best Results

• Use a clear, well-lit, front-facing reference photo. Poor-quality references produce poor-quality identity locks.
• PuLID's "Fidelity" method gives the closest face match. "Style" gives more creative freedom but less resemblance. Start with Fidelity.
• If the face looks "burned" or over-saturated, lower the CFG value and/or the InstantID weight.
• Generate multiple images with different seeds — pick the best ones for your character sheet.

What is a LoRA?

LoRA stands for Low-Rank Adaptation. In plain English: it's a small "memory file" (typically 20-80MB) that teaches an AI model to recognize a specific character.

Think of the AI model as a massive brain that knows millions of faces but doesn't know your character. A LoRA is a compact add-on that teaches this brain one specific identity — face, body type, hair, tattoos, signature features — everything that makes your character unique.

Once trained, this LoRA file becomes a reusable "character ID card." Every time you generate content, you load the LoRA and the AI knows exactly who to draw. This is why LoRA training is considered the gold standard for NSFW AI video character consistency.

What is a Character Sheet?

A character sheet is a collection of 15-20 images showing the same character from different angles, expressions, poses, and outfits — similar to the reference sheets used in professional animation. These images become the "textbook" that teaches your LoRA.

How to Do It

1. Build your dataset: Use Method 1 (InstantID/PuLID) to generate 15-20 images of your character from different angles and poses. Or use instruction-based editing tools like Qwen Image Edit to create variations from a single source image.
2. Curate quality: Review each image carefully. Remove any where the character looks off — wrong eye color, different nose shape, inconsistent features. Bad training data creates bad LoRAs.
3. Train the LoRA: Use AI Toolkit (Ostris) or Kohya_SS. Settings: ~1,500-2,500 training steps, network dimension 16. On a 12-16GB GPU, training takes about 15-30 minutes. No local GPU? Use RunPod or similar cloud services.
4. Apply it: Load your trained LoRA in ComfyUI when generating images or NSFW AI video content. Recommended weight: 0.6-1.0. Too high and you'll get artifacts; too low and the identity won't hold.

Step-by-Step: Using Your LoRA in ComfyUI

Once you've trained your character LoRA (you'll get a .safetensors file, typically 20-80MB), here's exactly how to use it in ComfyUI:

1. Add the LoRA File

Copy your trained .safetensors file into the ComfyUI/models/loras/ folder. If ComfyUI is already running, restart it so it detects the new file.

2. Add the Load LoRA Node

In ComfyUI, right-click anywhere on the canvas → Add Node → loaders → Load LoRA. A new node will appear with three settings: lora_name, strength_model, and strength_clip.

3. Connect It to Your Workflow

The Load LoRA node goes between your Checkpoint Loader and the KSampler. Here's the chain: Load Checkpoint → Load LoRA → KSampler. Connect the MODEL output from Checkpoint to the Load LoRA's model input. Then connect Load LoRA's MODEL and CLIP outputs to wherever your Checkpoint previously connected (usually KSampler and your prompt nodes).

4. Configure the Settings

1. lora_name: Click the dropdown and select your .safetensors file from the list
2. strength_model: Start at 0.7. This controls how strongly the LoRA influences the generated image. Higher = more like your character but risk of artifacts. Lower = less resemblance but more natural-looking.
3. strength_clip: Start at 0.7. This controls how much the LoRA influences the text prompt interpretation. Usually keep this the same as strength_model.

5. Use the Trigger Word

When you trained the LoRA, you likely set a "trigger word" — a keyword that activates the character (e.g., "ohwx woman" or "mychar"). Include this trigger word in your positive prompt along with your scene description. For example: "ohwx woman, standing on a balcony, sunset lighting, wearing white sundress".

Bonus: Stacking Multiple LoRAs

You can chain multiple Load LoRA nodes in sequence — for example, one for your character identity and another for a specific art style. Just connect them in series: Checkpoint → LoRA 1 → LoRA 2 → KSampler. Lower the strength of each (0.4-0.6) when stacking to avoid conflicts.

Why Pure Text-to-Video Fails

If you type "a woman walking on the beach" into a text-to-video generator, the AI imagines a new woman every time. Even with a LoRA loaded, pure text-to-video gives the AI too much creative freedom — and freedom is the enemy of consistency. The key insight: consistency is a constraint problem, not a creativity problem.

The Models: Wan 2.2 & Wan 2.1 VACE

The Wan series by Alibaba is the current gold standard for open-source AI video generation in ComfyUI. Two versions matter:

Wan 2.2 (Recommended)

Wan 2.2 is the latest open-source release (Apache 2.0 license). It uses a Mixture-of-Experts (MoE) architecture — 27 billion total parameters with 14 billion active per generation step. Compared to Wan 2.1, it was trained on 65% more images and 83% more video data, resulting in noticeably better motion coherence, aesthetics, and prompt understanding. It supports Text-to-Video, Image-to-Video, and runs natively in ComfyUI. The 5B variant (TI2V-5B) can generate 720p video on a single RTX 4090.

Because Wan 2.2 is open-source and runs locally on your own machine, it doesn't have the same cloud-side content moderation that commercial API services enforce. Your generations stay on your computer and are not filtered by a remote server. That said, always use AI-generated content responsibly and in compliance with your local laws.

Wan 2.1 VACE (Still Widely Used)

VACE stands for Video All-in-one Creation and Editing. This older model remains popular because many existing ComfyUI workflows and tutorials are built around it, and it has mature support for Reference-to-Video, Image-to-Video, and Control Video modes. If you find a tutorial or workflow online that uses "Wan VACE," it's almost certainly the 2.1 version. It's still a solid choice, especially if your GPU has less VRAM.

Reference-to-Video

You provide a character reference image, and the model uses it as a visual anchor throughout the video. The AI references this image to maintain consistent style, face, and details — even when the character moves or the camera angle changes. Think of it as pinning your character's photo to the AI's desk while it works.

Image-to-Video (I2V)

You start with a static image — perhaps one you generated with your character LoRA — and animate it. Since the character's appearance comes directly from the input image, consistency is naturally preserved. This is the most reliable path for short NSFW AI video clips.

Control Video

You provide a "skeleton video" — either a pose sequence or a real video showing the motion you want — and the model maps your character onto it. Imagine having a dance video and replacing the dancer with your AI character while keeping every move intact.

How to Use It

1. Prepare a character image using Method 1 or 2
2. Load the Wan 2.2 model in ComfyUI (14B MoE recommended for quality, 5B TI2V for RTX 4090 users). Or load Wan 2.1 VACE if your existing workflow is built around it.
3. Choose your mode: Reference-to-Video if you have a motion reference, I2V if you just want to animate a still image
4. Write a simple prompt describing the action + connect your reference image → Generate

Key Tips

• Match your reference image resolution to the video output resolution — mismatches cause quality drops
• Start with short clips (2-5 seconds) to verify character stability before going longer
• The 14B model requires 24GB+ VRAM. If you have less, use quantized versions (GGUF) that run on 8-12GB. The Wan 2.2 5B variant is optimized for consumer GPUs.
• If you're starting fresh, go with Wan 2.2. If you already have a working Wan 2.1 VACE pipeline with trained LoRAs, weigh the cost of retraining before migrating.

Why You Can't Just Generate Long Videos

Current AI video models accumulate errors over time. The first few seconds look great, but each additional frame introduces tiny deviations — slightly different nose, shifted eye color, drifting hair. By 10+ seconds, these compound into visible identity drift. Think of it like photocopying a photocopy: each generation degrades the original.

What is First-Last Frame (FLF)?

FLF is elegantly simple: you tell the AI "here's what frame 1 looks like, and here's what the final frame looks like — now fill in the motion between them." Because both endpoints are locked, the AI has far less room to drift. It's like connecting two dots with a smooth line instead of drawing freehand.

The Workflow

1. Generate keyframes: Use your character LoRA + an image model to create the start and end images for each shot. Plan your "storyboard" — what's happening in each 2-5 second segment.
2. Generate each short clip: Feed each start/end frame pair into LTX 2.3 or Wan 2.2's FLF mode. Each clip will have smooth, consistent motion between the two frames.
3. Stitch clips together: Use any video editor (even free ones like DaVinci Resolve) to join your clips. Add transitions between segments to smooth the connections.
4. Touch up if needed: If any individual clip has minor face drift, apply Method 5 (face swap repair) to fix specific frames.

Why This Is the Community Standard

This method isn't elegant, but it's the most reliable way to create longer NSFW AI video content with consistent characters. The community has converged on this approach because it works: short clips minimize drift, FLF locks the endpoints, and stitching gives you full control over pacing and flow. Many creators routinely produce 30-60 second videos this way by chaining 8-15 short shots.

What is ReActor?

ReActor is a face-swapping node for ComfyUI. It scans each frame of your video, detects faces, and replaces them with a target face you specify. It also includes built-in face restoration (CodeFormer) that automatically enhances facial details and fixes distortions after swapping.

Its Role in the Workflow

ReActor is not a primary production tool — it's a repair tool. Use it when you've generated an NSFW AI video using Methods 2-4 and the result is 90% good, but a few frames have minor face drift. ReActor patches those frames by re-applying the correct face identity.

How to Use It

1. Load the ReActor node in ComfyUI
2. Input: your generated video + a clear reference face image of the character
3. ReActor processes frame-by-frame, replacing faces + running CodeFormer restoration
4. Output: the repaired video with consistent face identity