Text To Pixel Character

If you've ever stared at a generated character and wished it looked like it crawled out of an old JRPG, this node is that wish, packaged as a single box. Text To Pixel Character takes a plain-English character description and hands you a 512x512 pixel-art sprite - chibi proportions, flat colors, the works - without you touching a single upscaler, palette, or quantization node. It's the "one-node workflow" idea taken literally: the entire pipeline, compressed into one box.

It's the author's first formal project, and that shows in both directions. The idea is genuinely nice: instead of generating high-res and hoping, it bakes the pixel-art conversion into the node, so you get the same palette and style across every generation - and consistency is the thing that normally separates usable sprite pipelines from random cool outputs. The rough edges are in the details, and the biggest one is that it won't find your models unless you put them exactly where it's looking.

How it works

Under the hood it's a full SDXL pipeline with training wheels. The node loads a checkpoint, applies a LoRA, encodes your prompt plus a hidden style prompt ("Pxstyle, pixel art, chibi, big head, small body, fullbody RPG character sprite..."), runs 28 steps with euler/karras at CFG 5.0 on a 256x256 latent, and VAE-decodes. Then the interesting part: it shrinks the image to 64x64 with nearest-neighbor scaling, nudges the colors toward palette.png with a simple RGB color match, quantizes down to 32 colors with no dithering, and scales back up to 512x512. Nearest-neighbor is the right call for pixel art here - Lanczos or an ESRGAN model would smear those hard pixel edges into mush, which is exactly what you don't want in a sprite.

The inputs that matter

There are only four, and all of them are required:

• character_prompt - the only one you'll actually fiddle with. Multiline, defaults to "red haired female knight, blue dress, brown leather boots, small cape".
• ckpt_name / lora_name - dropdowns that list models found in the node's own folders.
• seed - controls the roll, with a "control after generate" button so you can cycle seeds.

The output is a single image tensor, so your whole workflow is basically this node wired straight into Save Image.

Installing it

Via ComfyUI Manager, search for "ComfyUI_Text2PixelCharacter", or:

cd ComfyUI/custom_nodes
git clone https://github.com/BlancheVall/ComfyUI_Text2PixelCharacter

Restart ComfyUI, then look for "Text To Pixel Character" in the node list. The good news: requirements.txt is actually empty. numpy, Pillow, and torch ship with ComfyUI already, so there's nothing heavy to install and no dependency hell. No model files are bundled either - you supply the checkpoint and LoRA yourself.

The gotcha that will waste your afternoon

The node does not read your normal models/checkpoints and models/loras folders. On import it creates checkpoints/ and lora/ subfolders inside its own custom node directory and only lists files that live there. Until you drop something in, both dropdowns read "NO_CHECKPOINT_FOUND" and "NO_LORA_FOUND", and generation dies with a FileNotFoundError. It's buried in the README's features list, not in the install steps, so it's the #1 way to brick this thing on first run. Drop your SDXL checkpoint and a pixel-art/chibi LoRA into those subfolders, restart, and the dropdowns populate. LoRA strength is fixed at 0.68 model / 0.80 clip, and there's no input to change it.

Where you're otherwise stuck

The sampler, steps, CFG, style prompt, and negative prompt are all hardcoded constants, not inputs. If the built-in chibi look isn't yours, you can't tune it - your only levers are swapping the checkpoint/LoRA or replacing palette.png in the project root with your own palette reference (that one actually shifts the color style noticeably). And because it's a first project from an unknown author, give the ~7KB source a skim before you run it. It's short and clean, and reading 7KB is cheap insurance - you should never install an unknown custom node blind.

Verdict

It's a fun toy and a decent reference for a sprite pipeline, and the fixed palette plus quantization genuinely deliver consistency roll after roll. But the r/comfyui thread where the author showed it off got a blunt "still pretty terrible quality for pixel art," and the counter-suggestion - train a small pixel LoRA and keep the post-processing you actually want - is the road people end up on for production sprites. For rolling a few characters to see if the chibi-sprite look fits your game, though, this is about the fastest single node you'll find.