FantasyNameCraft

How I Build a Name Generator the Way I Actually Use It

Why I Build First for Feel

Most people start with code. I start with feel. If a generator doesn’t produce names I’d personally use in a game, it’s not ready. So I design each generator like a tiny instrument: it should have a tone (genre), a scale (letter rules), and a rhythm (syllable flow). When you press “Generate,” it should sound right—even before you read it twice.

My Three Layers (Vibe → Rules → Output)

I build every generator in three passes:

  1. Vibe — What does this world feel like? Iron and ash? Moonlit forests? Neon glitch?

  2. Rules — What letter shapes and syllable patterns match that vibe? (Hard K/Z for menace; L/M/N for warmth.)

  3. Output — Batches of 20–50 names at a time, so I can judge the spread, not just a lucky hit.

Only after the vibe works do I care about options and UI.

The Word Vault (Seeds, Shards, and Shelves)

I keep a word vault for each theme, split into three “shelves”:

  • Roots (seeds): Core meaning chunks (light, storm, ash, oath, thorn, aur, val, noct).

  • Affixes (shards): Prefixes/suffixes that shape tone (mal-, aur-, -ion, -wyn, -rax).

  • Phonemes (sound tiles): Small sound units that define the mouthfeel (e.g., ae, th, ry, ul, kh, zy).

I label each item with tags like heroic, sinister, airy, metallic, ancient, sylvan, arcane. The engine weights those tags so a “dark forest” generator favors sylvan + sinister pieces while down-weighting metallic sounds.

Syllable Shapes (The Secret Sauce)

If there’s one thing that prevents junk output, it’s syllable shape rules.
I define a small grammar like:

  • C = consonant, V = vowel, L = liquid (l, r), S = sibilant (s, z, sh).

  • Hero pattern examples: CV, CVL, CVCV (open, flowing).

  • Villain pattern examples: CVS, CLVC, CVSC (tighter, sharp).

Then I allow a controlled chaos: 70% picks from preferred shapes, 30% from wildcards for surprise. That gives variety without nonsense.

Weighted Choices (So Every Click Feels Intentional)

I don’t treat all pieces equally. I assign weights so the generator prefers certain sounds but still explores:

  • High weight: sounds that define the theme (e.g., ae, el, th for elves).

  • Medium weight: spices that mix well (e.g., -ion, -aris).

  • Low weight: rare accents for highlights (e.g., -yx, -qir).

This keeps 80% of outputs “on-model” and 20% pleasantly odd.

Blacklists, Whitelists, and Near-Duplicates

Two things ruin trust: bad collisions and lookalike spam.

  • Blacklist: Blocks awkward letter collisions (e.g., aa in the wrong place, q without u in certain genres), banned real-world terms, and repetitive double-consonants that stall pronunciation.

  • Whitelist: Known-good combos I want to surface more often (e.g., -wyn, -riel, -var for high fantasy).

  • Near-duplicate check: If “Valion” exists, the engine downranks “Valyon,” “Valian,” etc., in the same batch.

Pronounceability Tests (The Whisper + Shout Rule)

Every good name passes two quick tests:

  1. Whisper: If it dies in a whisper, it’s too crowded with consonants.

  2. Shout: If it tangles in a shout, the rhythm’s wrong.

In code terms, I measure vowel spacing and consonant clusters. In human terms, I just say it out loud—fast.

Genre Filters (Locks That Keep the Vibe Safe)

I bind each generator to a genre profile:

  • High Fantasy: open vowels, liquid consonants, soft endings; titles allowed.

  • Dark Fantasy: muted vowels, fricatives, thorny clusters; ruin/rot lexicon.

  • Sci-Fi: clipped syllables, model codes, clean numerics (sparingly).

  • Mythic: grand suffixes, ceremonial particles, and permission for 4+ syllables.

Switching profile flips weights, allowed patterns, and the lexicon itself.

My Real Workflow (How I Use My Own Tools)

When I sit down to name a character, I don’t click once and quit. I run batches:

  1. Generate 30. First pass: circle 3–5 that feel right.

  2. Remix. Swap endings, try the same root with two moods (Aur- → Auriel vs Aurax).

  3. Leaderboard test. Picture it on a UI: quest log, nameplate, or boss bar.

  4. Out loud. Whisper. Shout. If it works both ways, it makes the shortlist.

I build the generator to mirror that loop—batch output, “favorite” buttons, quick remixes, copy-to-clipboard.

Tuning for Players (Options That Actually Matter)

I expose controls that change tone, not noise:

  • Mood slider: Heroic ↔ Sinister (shifts weights, syllable shapes, and endings).

  • Length: Short / Medium / Long (changes pattern allowance).

  • Formality: Commoner ↔ Noble (unlocks titles, adds ceremonial particles).

  • Culture hints: Elven, Orcish, Arcane, Rustic (swaps lexicon shelves).

  • Duplicate guard: “No similar names in this batch.”

No lorem-ipsum controls. Everything maps to a real rule.

Guardrails Against “AI Mush”

Even with smart rules, generators can drift. My guardrails:

  • Top-X caching: I pin proven winners so they recur as reference points.

  • Bad-combo decay: If users consistently skip a pattern, its weight falls.

  • Human curation: I routinely prune seeds that read like noise.

When I Ship

I ship when a random 50-name batch gives me 5+ names I would genuinely use in a real game. If I have to cherry-pick just to make a screenshot, it’s not ready.

Final Thoughts

A great generator isn’t a slot machine—it’s a guided instrument. With the right vibe, rules, and output flow, you can click into a name that feels inevitable, like it was waiting for your character all along. That’s the whole point: make it fast, make it fun, and make it feel right every single time.