I have all the characters in my RPG (rpgdev) drawn by AI. The dot-pixel hero, the spirits of fire, water, wind, and earth, the enemy monsters. I've generated each one, made them transparent, and put them into the game.
But there's been a persistent problem: AI is bad at drawing the same character consistently.
Suppose you get a good character image. You ask for "the same character, but facing sideways" or "a damaged version." Then — it's not like it becomes a different person, but the hairstyle changes a bit. The colors shift. Equipment appears or disappears. The line thickness varies. Each image looks fine on its own, but when lined up, they don't look like "the same character."
I couldn't trust the approach of editing a single image to create variations, in terms of consistency.
By the way, in a previous article How I turned my terminal into an RPG, I wrote that I struggled with creating these dot-pixel variants and ended up ordering a 32GB GPU to "fight back." This article is also a record of that rematch.
The overall two-stage approach: stop endlessly fixing single images, first create a reference sheet to serve as a standard
How do anime and manga studios keep characters consistent?
I thought about it. How do professional animators and manga artists keep the same character consistent across every cut and every episode?
I know the answer: Character reference sheets (model sheets). Front, three-quarter, side, and back turnaround views, expression patterns, several poses. A single sheet that serves as a standard for "this is how to draw this character." Everyone on the team draws while looking at this sheet. That's why they can maintain the same character across hundreds of cuts.
So, we should make AI do the same thing. Instead of endlessly fixing single images, first create one reference sheet, and then use it as the standard for all subsequent generations. The idea itself is simple.
The problem was: how to make AI create that reference sheet itself.
The key is in how you create the reference sheet
If you do it straightforwardly, it goes like this: "Draw a front view," "Next, a side view," "Next, a back view," "Next, a smiling face" — generating each cut one by one separately.
But this leads to the same problem as before. The character drifts between cuts. They become different people within the reference sheet. The sheet meant to be the standard fails to be a standard. It's putting the cart before the horse.
So I came up with a two-stage approach.
Stage one: Have all angles, expressions, and poses drawn together in a single generation. Don't request them separately. Ask for "a reference sheet with turnarounds, expressions, and poses all in one image" in a single prompt. Because they are drawn simultaneously as one picture, they are consistent with each other within it. The front and back views have the same hairstyle and same outfit. This becomes the "anchor for consistency."
The master sheet drawn all at once
However, cramming everything into one image makes each cut small and rough. The resolution isn't enough for game use.
So, stage two: Now pass that "group drawing" sheet back to AI as a reference. Then have it redraw each cut individually at high resolution. Ask: "Keep the character exactly as shown in this reference, but draw only this one cut larger."
With a reference, consistency is maintained. By drawing each cut individually, resolution is achieved. Consistency from the reference sheet, resolution from individual generation — both benefits. I designed and instructed this two-stage approach myself.
Here's the result. At the top is the master sheet; below it are high-resolution redraws of turnarounds, expressions, actions, alternate outfits, chibi versions, equipment, and even an extracted color palette. All the same character.
The character bible with each cut redrawn from the master sheet
The water spirit. Expressions, running, jumping, knight armor, dress — all lined up as the same person.
Bonus: The reference sheet becomes fuel for mass production
The high-resolution cuts created in stage two have another use.
They become training data dedicated to that character. You have a dozen or more images of the same character from various angles and expressions. If you train an AI on these to create a small additional model that "remembers" this character, you can mass-produce new poses that weren't in the reference sheet, while keeping the character consistent.
The process of creating the reference sheet also doubles as fuel for the next mass production. That was intentional.
Turning pain points into "checkpoints"
That's the core. Now a little about the tool's internals.
While creating assets for rpgdev, I've stepped on countless small pain points. I've baked each one into the tool as an "absolute rule" (checkpoint).
The output is a transparent game sprite. If the corners aren't properly transparent, it gets rejected before shipping.
| Pain points I encountered | Absolute rules (checkpoints) baked in |
|---|---|
| Black residue in transparency - "Closed black" areas like gaps between arms and ribbons remain after simple background removal. One accepted image had over 200,000 black pixels left. | Reject before shipping if the four corners aren't properly transparent. |
| Misalignment in damage versions - Each regeneration shifts by a few pixels, causing misalignment with the base in-game. | Reject if not within 1px of the base. |
| Art style drift - Omitting essential terms for retro pixel art causes a smooth slide into glossy anime style. | Automatically inject those terms. |
| Manual fixes don't work - Hand-drawing fabric, skin, or outlines to fix issues had a zero percent success rate. | Don't include manual editing functions. To fix, regenerate. |
Broken assets don't silently slip into the game. They get stopped at the checkpoint.
And whether the input comes from a human-operated UI (WebUI) or an AI (Claude or Codex) calling the MCP endpoint, the same processing pipeline is used. So whichever face enters, these checkpoints cannot be bypassed.
With 32GB, it finally worked
In #30, I wrote that my custom diff tool couldn't run on my 16GB GPU, so I ordered a 32GB one to "fight back."
The editing model this tool uses gobbles up over 20GB of VRAM. It simply didn't fit in 16GB — literally zero images were output. After upgrading to 32GB, it finally worked. If you don't have enough VRAM, that's the end of it.
On top of that, the architecture is designed as follows: the heavy generation is entirely handled by that single machine with 32GB (the ComfyUI GPU machine). The main tool is a thin orchestrator that commands "what to create and in what order" and performs the checkpoint checks mentioned earlier. As long as you have one machine set up for generation, the orchestrator can connect from a Mac or WSL.
It's a tool that requires a CUDA GPU and the full ComfyUI setup — it has requirements. But the two-stage concept itself is tool-agnostic. If you're struggling with inconsistent characters, you can take just that idea and it will work.
Conclusion
sprite-forge. Create transparent game-ready characters from text. Give it an idea, and it produces a base body, assembles a reference sheet, and even prepares training data for that character. Whether from a human or an AI agent, the same checkpoints are passed and the same output comes out.
The repository is at github.com/kitepon-rgb/sprite-forge-mcp. MIT license.
I stopped endlessly fixing single images and started creating from a reference sheet. At last, the same character now lines up as the same character.
Top comments (0)