How to Build a Naming Language for Worldbuilding

You do not need to invent a language to make your invented names sound like they belong to one. You need something much smaller and much faster: a naming language — a locked sound inventory, a handful of syllable shapes, a short list of forbidden combinations, and thirty or forty roots you can recombine forever. No grammar, no verb conjugation, no case system. Just enough structure that a reader's ear recognizes "these names come from the same place" without being able to say why.

This guide builds one from nothing, in public, using a single invented example so you can watch every decision land somewhere concrete. The language is Kessari, spoken by nomadic riders on the plains of a continent we're calling Vaelgard — the same kind of setting our own fantasy continent name generator spins up on request, except here you get to see the naming system behind a continent built by hand, step by step, instead of assembled at random. By the end you will have a sound inventory, a syllable template, five phonotactic rules, forty morphemes, four word-formation rules, and thirty finished Kessari names — people, places, and clans — built from exactly those pieces.

None of this requires linguistics training. It requires an evening, a short list of constraints, and the discipline to actually follow them once you've written them down.

What a Naming Language Actually Is (and Isn't)

A constructed language — a conlang — is a complete language someone built on purpose: phonology, morphology, syntax, a real vocabulary that can express "the merchant sold his horse to the king's cousin before the harvest." People spend years on these. Tolkien spent decades on Quenya and Sindarin, and it shows in every case ending.

A naming language is a fraction of that project aimed at a fraction of the goal. You are not trying to write sentences. You are trying to name people, places, and things so consistently that a reader can tell a Kessari name from a name belonging to the kingdom next door without you ever explaining the difference. That needs a sound inventory, syllable shapes, a set of bans on what can't combine, and a small lexicon of roots — nowhere near a full grammar. Where a conlang is a multi-year hobby project, a naming language is an evening's work that gets you most of the payoff a reader actually notices.

The term itself comes out of the online constructed-language community, not academic linguistics — it's a distinction conlangers themselves draw between a full personal-use or art language and the stripped-down system writers and game masters build purely to generate plausible names. Mark Rosenfelder's The Language Construction Kit, one of the field's foundational texts, is where the idea first got written down for a wide audience; we link the source at the end of this guide. The shortcut he describes is exactly what this guide walks through in full, on one worked example, from the first consonant to the thirtieth finished name.

Here's the trade you're making: a conlang can tell a story in its own words. A naming language can only ever label things — but it labels them so consistently that thirty names in a row read as one culture instead of thirty coin-flips.

Step 1: Pick a Sound Inventory (and Give It a Character)

The first decision has nothing to do with names yet. It's a budget: which consonants and vowels this language uses, full stop. Not "sounds I like." A budget, with a hard ceiling and exclusions you can point to. Every real language is defined as much by what it leaves out as by what it includes — Hawaiian gets its unmistakable lilt partly from having only eight consonants total, and English gets its dense, clattering texture partly from tolerating consonant clusters that would sound impossible in Hawaiian. Neither inventory is "richer." Each is consistent because it's restrictive.

A workable target for an invented language: 8–12 consonants, 4–6 vowels, no more. Pick fewer and it starts sounding thin; pick more and every name has a slightly different flavor, because you're drawing from a bigger, less disciplined pool each time. The table below is a blank template — copy it for your own language — followed by the filled version we built for Kessari.

Ten consonants, four vowels. Notice what's missing on purpose: no o. Dropping one common vowel does more to make a language sound foreign than adding an exotic one would — every word keeps its mouth a little more open than English expects, and that alone gives Kessari its "wide plains, wind in the grass" character before a single word is built. We also left out b, d, p, and every fricative except s, sh, and v. A rider culture built around hoofbeats and open air didn't need a soft, hissing consonant set; it needed hard stops and rolling liquids, so that's what we gave it.

That's the actual lesson of this step, and it's the one most casual naming advice skips: "pick sounds you like" isn't a method, because it gives you no way to reject a candidate name later. A budget is a method. Once Kessari's ten consonants and four vowels are locked, any syllable using a sound outside that list is automatically illegal — no judgment call required, just a list you can check against.

Step 2: Choose Your Syllable Shapes (CV, CVC, CVCC)

A sound inventory tells you which letters are legal. It says nothing about how they combine, and that gap is where a lot of homemade languages quietly fall apart — every name draws from the approved sound list, but one is one syllable, the next is five, and there's no shared rhythm holding them together. Structure is the second constraint, and readers register it before they register anything else, because rhythm reaches the ear faster than vocabulary does.

The shorthand is simple: C stands for any consonant, V for any vowel. A syllable written CV is one consonant followed by one vowel — "ka," "ti," "mo." CVC adds a closing consonant — "kan," "tul." Real languages cluster around fairly consistent shapes, and the shape a language favors changes how it feels on the ear more than almost any other single choice you'll make.

For Kessari we picked CV(C) as the default — most syllables are open, a closing consonant is common but never mandatory — with a rare CVCC shape allowed only where two roots meet at a word boundary, never inside a single root. That gives the language most of Japanese's open, rolling texture while still allowing the occasional denser compound name, which is exactly the contrast we want: individual roots sound light and windswept, but stacking two of them into a place name or clan name can sound a little heavier, the way compounding often does in real languages too. A language built entirely from dense CVCC clusters would fit an insectoid hive far better than open-plains riders — which is the same logic our alien name generator leans on when it gives a hive species clattering consonant stacks and gives an energy-based species almost nothing but smooth vowels. Syllable shape is doing narrative work before a single word means anything.

Step 3: Set Your Phonotactic Bans

Here's the part almost nobody spells out clearly: the bans matter more than the permissions. A sound inventory and a syllable shape tell you what's allowed; a good naming language also needs a short list of things that are explicitly not allowed, because without bans, every combination the inventory permits gets used eventually — and a language that permits everything sounds like static, not speech.

Kessari runs on five rules:

1. No two stops in a row. K, t, and g can't sit directly next to each other — a vowel, liquid, or nasal has to separate them. "Katga" is illegal; "Katanga" or "Kalga" is fine.
2. /r/ never ends a word. A root or name can end in n, s, or l, but never r — if a rule would produce a word-final r, it softens to l instead. This is one small rule that quietly shapes dozens of names later.
3. Nasals assimilate before stops. N shifts to m before k or g — the same place-of-articulation assimilation that gives English "impossible" its m instead of the "in-" it started as. "Tanka" becomes "Tamka" in casual Kessari speech, and both forms coexist the way archaic and modern forms often do in a living language.
4. S and sh never touch. No "s-sh" or "sh-s" clusters — pick one sibilant per syllable boundary, not both.
5. Codas are limited to n, r, s, and l. A syllable can close on one of those four consonants and nothing else — k, t, g, v, m, and sh can only ever open a syllable, not close one.

Watch what happens when you generate syllables with the inventory and shape from Steps 1–2 but skip the bans entirely: ka, tush, gara, mvish, skta, rutn, vashk, tgor. Some of those are unpronounceable; none of them share a family resemblance. Filter the exact same random process through the five rules above and you get: ka, tush, gara, munish, rasu, veltan, kolun, tarish. Same sound inventory, same syllable shapes — but now every result is pronounceable and every result sounds like it belongs to the same speaker. The bans are what turned a pile of sounds into a system.

Step 4: Build a 40-Morpheme Lexicon (Not a Dictionary)

You don't need a dictionary. A naming language needs a lexicon just big enough to generate names without visibly repeating itself for a long while — in practice, that's around forty morphemes: root words plus a small number of grammatical particles. Go much smaller and the same three or four roots show up in every fifth name; go much bigger and you're most of the way to building an actual conlang, which is a different, much longer project.

Forty splits comfortably into three groups: noun roots (the bulk of it), a handful of adjective roots, and two or three particles that do grammatical work — a genitive or territorial marker, a diminutive, an agentive suffix that turns a quality into a person. Here is the complete Kessari lexicon, all forty entries, built for a nomadic plains culture whose vocabulary leans toward terrain, weather, kinship, and war:

Noun roots (26):

• vus — water
• gara — mountain
• teshu — wolf
• kandu — iron
• rai — chief, king
• morsu — enemy
• tel — home, tent
• sedu — wind
• ulan — horse
• nirv — fire
• kolu — stone
• vethu — river
• sanu — grass, steppe
• dorel — sky
• mira — moon
• asha — sun
• keth — blood
• varu — shadow
• lisan — song
• tursa — storm
• dun — clan, tribe
• vor — spear
• eshta — bone
• calu — tree
• rishu — hawk
• omek — night

Adjective roots (10):

• mek — big, great
• dara — old
• kiran — sharp
• golun — strong
• rasha — swift
• ivel — cold
• shael — bright
• nurath — hidden
• teska — broken
• velun — sacred

Grammatical particles (4):

• -ka — territorial/genitive suffix: "of, place of"
• -ish — diminutive/endearment suffix
• ro- — intensifying prefix: "very, great-"
• -ael — agentive suffix: "one who is/does"

That's the entire word-stock this guide uses to generate thirty finished names in Step 6. Nothing gets invented on the fly past this point — every name from here on is built strictly from these forty pieces and the five bans from Step 3.

Step 5: Word-Formation Rules (How Roots Become Names)

Forty morphemes on their own are just a word list. Word-formation rules are what turn them into names, and Kessari runs on four:

1. Compounding, with vowel elision at the seam. Two roots combine directly for place and clan names. If the first root ends in a vowel and the second begins with one, the first root's final vowel drops so the two don't collide: kolu (stone) + ulan (horse) → kolulan, "stone-horse," not the clumsier "koluulan." Where the seam is consonant-to-vowel or vowel-to-consonant, nothing drops: gara (mountain) + teshu (wolf) → garateshu, "mountain-wolf."
2. The territorial suffix -ka names a place after what defines it. vus (water) + -ka → vuska, "place of water" — a river settlement. tel (home) + -ka → telka, "homestead," the name a founding family gives the ground they first pitched a tent on.
3. Truncation plus -ish builds diminutives and nicknames. Cut a root to its first syllable and add the diminutive suffix: teshu (wolf) truncates to tesh, then + ish → teshish, "wolfling," a nickname earned rather than given at birth. rai (chief) → raish, "little chief," used for a chief's child long before they hold the title.
4. The agentive suffix -ael turns a quality into a person. Attach it to an adjective root and you get "the [quality] one": rasha (swift) + -ael → rashael, "the swift one," a name for a scout or rider. Where the root ends in a vowel that would collide with the suffix's own initial vowel, the same elision rule from compounding applies: rishu (hawk) + -ael → rishael, not "rishuael."

Four rules, and every name in the next section comes from applying one of them to the forty-morpheme lexicon above, filtered through the five phonotactic bans from Step 3. That's the whole naming language, spelled out in full before a single finished name appears.

Step 6: Generate and Test 30 Names

Here is Kessari doing its actual job: thirty finished names — people, places, and clans — built strictly from the sound inventory, syllable shapes, phonotactic bans, lexicon, and word-formation rules laid out above. Nothing below was invented outside that system.

A few of those are worth unpacking. Rishael shows the elision rule doing its quiet work — "rishu" plus "-ael" would collide two vowels, so the root's final u drops and the seam disappears cleanly. Kolulan does the same job in a place name: "stone" and "horse" fuse at the vowel boundary into something that reads as one word, not two stapled together. Morsudun, "enemy-clan," shows how compounding can carry a whole piece of backstory in eight letters — somewhere in this culture's past, a clan earned that name from people who weren't its own.

Now the test. Here's a name that was never built from any of this: Brakthorn. Read it next to the thirty above and the ear catches the difference before you can explain it — br is a cluster Kessari's syllable shape doesn't allow at a syllable onset, and both b and th sit outside the ten-consonant inventory from Step 1 entirely. It sounds like it wandered in from a different setting's Norse-flavored kingdom, because it did — and that instant, gut-level "this doesn't belong here" reaction is exactly what a functioning naming language buys you. You don't need to explain the phonotactic rule to a reader for it to work; their ear does the work for you.

Common Mistakes That Make a Naming Language Fall Apart

Five ways this collapses in practice, roughly in order of how often they show up in a first draft:

• The kitchen-sink inventory. Twenty-plus consonants with no hierarchy between them, because every sound "felt cool" in isolation. A big, undisciplined inventory produces names that don't share a family resemblance, because each one draws from a different corner of a pool too large to feel consistent.
• No phonotactic bans at all. Skip Step 3 entirely and any syllable the inventory permits eventually shows up, unfiltered. The result sounds like a random-syllable generator, because that's structurally what it is — a naming language without bans is just a word list with extra steps.
• An inventory with no character. A perfectly "balanced" set of sounds — one of everything, nothing dominant — has no flavor to recognize. Real languages lean: Hawaiian leans open and vowel-heavy, German leans consonant-dense. A naming language needs a lean, not a spreadsheet.
• A lexicon that's a thin costume over a real language. Roots that are obviously "Elvish Spanish" or "fantasy Japanese" with the serial numbers filed off read as exactly that, and it breaks immersion the instant a reader notices the source. Borrow texture, not recognizable words.
• Abandoning your own rule on the thirty-first name. The most common failure of all: the system holds for the first cast of characters, and then a name needs to "sound cooler" so a rule quietly gets broken with no in-world reason. One deliberate exception per fifteen or twenty names reads as texture. An undisciplined one reads as the author giving up.

Turning Your Naming Language into Generator Data

Everything in Steps 1 through 5 maps almost directly onto how a real name generator is built — which is worth knowing whether you're planning to code one yourself or just want to understand what's happening under the hood of the generators on this site. Every generator here runs on one shared engine (_engine.ts) with per-niche data files that supply the actual sounds, and the shape of that data is close to a direct translation of what you just built for Kessari.

A sound inventory becomes three arrays — onset, vowel, and coda — one entry per legal sound in that slot. A syllable shape becomes the logic that decides how many of those arrays get drawn from and in what order. Phonotactic bans become a filter function that rejects any combination the rules disallow before it ever reaches the screen. A lexicon becomes arrays of roots and suffixes. Word-formation rules become the build() function that combines them. Simplified, Kessari's engine data would look roughly like this:

const KESSARI_ONSET = ["v", "s", "sh", "n", "m", "r", "l", "k", "t", "g"];
const KESSARI_VOWEL = ["a", "e", "i", "u"];
const KESSARI_CODA   = ["n", "r", "s", "l", ""];

function syllable(): string {
  const onset = rand(KESSARI_ONSET);
  const vowel = rand(KESSARI_VOWEL);
  const coda = rand(KESSARI_CODA);
  return onset + vowel + coda;
}

function isLegal(syl: string): boolean {
  // Step 3's five bans live here: no stop+stop, no word-final r,
  // nasal assimilation before stops, no s+sh, coda restricted to n/r/s/l.
  return true; // filter logic omitted for brevity
}

That's the same pattern our species name generator runs on for every fantasy race, beastfolk culture, and hive species it offers — each one has its own onset/vowel/coda pools tuned to a different phonetic character, exactly the way Kessari's pools are tuned to sound like open plains rather than a mountain hold or an insect hive. Build the naming language on paper first, the way this guide just did, and turning it into working generator code later is mostly bookkeeping — the creative decisions are already made.

FAQ

What's the difference between a conlang and a naming language?

A conlang is a complete language — phonology, grammar, syntax, a vocabulary big enough to build sentences with. A naming language keeps the phonology and syllable rules but drops grammar and syntax entirely, staying just big enough (a sound inventory, syllable shapes, a few dozen roots) to generate consistent names. A conlang can take years; a naming language like Kessari can be built in an evening.

How many words do I need for a naming language?

Around forty morphemes is a comfortable working size — enough noun and adjective roots plus a few grammatical particles that names don't visibly repeat for a long while, without ballooning into a real dictionary. Kessari's full lexicon in this guide has exactly forty entries, and it's enough to generate hundreds of distinct names before any two feel suspiciously alike.

Do I need to learn the IPA to build a naming language?

No. Ordinary letters and combinations like "sh" or "th" work fine for a naming language, since you're not trying to represent every possible human speech sound precisely — you're trying to write consonants and vowels consistently enough that you and your readers agree on how they sound. Save the International Phonetic Alphabet for if you ever want to build a full conlang with genuinely unusual sounds.

Can two cultures in my world share a naming language?

Yes, and it's a good way to signal history — two nations that share an inventory and syllable shape but differ in lexicon and word-formation rules read as related peoples who split apart generations ago, the same way related real-world language families do. Keep the sound system close and vary the roots and suffixes if that's the story you want to tell.

How do I make my invented names easy to pronounce?

Lean toward open syllables (CV over CVCC), limit consonant clusters, and keep your coda list short the way Kessari restricts closing consonants to just n, r, s, and l. The harder a name is to sound out on first read, the more readers silently rename it in their heads — which defeats the point of naming it carefully at all.

Can I use a naming language for non-human species — aliens, monsters, hiveminds?

Absolutely, and the process doesn't change — only the sound inventory does. A harsh, clicking inventory with heavy consonant clusters reads as insectoid or reptilian; a smooth, vowel-heavy one reads as ethereal or energy-based. Our alien name generator runs seven species profiles built exactly this way, each with its own locked inventory rather than one generic "alien-sounding" template.

Sources and further reading

• Mark Rosenfelder, The Language Construction Kit (zompist.com/kit.html) — the source most often credited with popularizing the term "naming language" as a lightweight alternative to a full conlang, within the online constructed-language community.
• A. K. Larkwood, "Build a Fantasy Naming Language in One Afternoon" (aklarkwood.com/naming-language) — a practical, phonetics-forward walkthrough of the same general idea, worth reading for its treatment of consonant articulation.
• rassaku, "Naming Languages, Part I: Why Names in Fantasy Often Suck" (rassaku.livejournal.com) — a sharp diagnosis of why mixing unrelated real-world naming traditions in one setting breaks reader trust, and the problem a naming language exists to solve.
• General syllable-structure typology: Hawaiian's restricted, largely open-syllable phonology and the consonant-cluster tolerance of Germanic and Slavic languages like German and Polish are well-documented, widely cited facts of phonological typology, referenced here as general background rather than drawn from a single source.