diff --git a/world/src/civ/mod.rs b/world/src/civ/mod.rs
index a6949a5a97..1748f489ea 100644
--- a/world/src/civ/mod.rs
+++ b/world/src/civ/mod.rs
@@ -514,35 +514,32 @@ impl Civs {
         let mut biome_count = 0;
         for biome in biomes {
             let name = match biome.0 {
-                common::terrain::BiomeKind::Forest if biome.1.len() as u32 > 750 => Some(format!(
+                common::terrain::BiomeKind::Lake if biome.1.len() as u32 > 200 => Some(format!(
                     "{} {}",
-                    NameGen::location(&mut ctx.rng).generate_temp_forest(),
-                    [
-                        "Forest",
-                        "Woodlands",
-                        "Woods",
-                        "Glades",
-                        "Grove",
-                        "Thickets",
-                        "Weald"
-                    ]
-                    .choose(&mut ctx.rng)
-                    .unwrap()
+                    ["Lake", "Loch"].choose(&mut ctx.rng).unwrap(),
+                    NameGen::location(&mut ctx.rng).generate()
+                )),
+                common::terrain::BiomeKind::Lake if biome.1.len() as u32 > 10 => Some(format!(
+                    "{} {}",
+                    NameGen::location(&mut ctx.rng).generate(),
+                    ["Pool", "Well", "Pond"].choose(&mut ctx.rng).unwrap()
                 )),
                 common::terrain::BiomeKind::Grassland if biome.1.len() as u32 > 750 => {
                     Some(format!(
                         "{} {}",
-                        NameGen::location(&mut ctx.rng).generate_grassland(),
+                        NameGen::location(&mut ctx.rng).generate_grassland_engl(),
                         [
                             "Grasslands",
-                            "Flats",
-                            "Greens",
                             "Plains",
                             "Meadows",
                             "Fields",
                             "Heath",
+                            "Hills",
+                            "Prairie",
+                            "Lowlands",
                             "Steppe",
-                            "Downs"
+                            "Downs",
+                            "Greens",
                         ]
                         .choose(&mut ctx.rng)
                         .unwrap()
@@ -550,13 +547,15 @@ impl Civs {
                 },
                 common::terrain::BiomeKind::Ocean if biome.1.len() as u32 > 750 => Some(format!(
                     "{} {}",
-                    NameGen::location(&mut ctx.rng).generate_biome(),
-                    ["Ocean", "Blue", "Deep"].choose(&mut ctx.rng).unwrap()
+                    NameGen::location(&mut ctx.rng).generate_ocean_engl(),
+                    ["Sea", "Bay", "Gulf", "Deep", "Depths", "Ocean", "Blue",]
+                        .choose(&mut ctx.rng)
+                        .unwrap()
                 )),
                 common::terrain::BiomeKind::Mountain if biome.1.len() as u32 > 750 => {
                     Some(format!(
                         "{} {}",
-                        NameGen::location(&mut ctx.rng).generate_biome(),
+                        NameGen::location(&mut ctx.rng).generate_mountain_engl(),
                         [
                             "Mountains",
                             "Range",
@@ -569,7 +568,7 @@ impl Civs {
                             "Bluffs",
                             "Ridge",
                             "Canyon",
-                            "Plateau"
+                            "Plateau",
                         ]
                         .choose(&mut ctx.rng)
                         .unwrap()
@@ -578,14 +577,17 @@ impl Civs {
                 common::terrain::BiomeKind::Snowland if biome.1.len() as u32 > 750 => {
                     Some(format!(
                         "{} {}",
-                        NameGen::location(&mut ctx.rng).generate_biome(),
+                        NameGen::location(&mut ctx.rng).generate_snowland_engl(),
                         [
                             "Snowlands",
                             "Glacier",
                             "Tundra",
+                            "Drifts",
                             "Snowfields",
                             "Hills",
-                            "Highlands"
+                            "Downs",
+                            "Uplands",
+                            "Highlands",
                         ]
                         .choose(&mut ctx.rng)
                         .unwrap()
@@ -593,14 +595,16 @@ impl Civs {
                 },
                 common::terrain::BiomeKind::Desert if biome.1.len() as u32 > 750 => Some(format!(
                     "{} {}",
-                    NameGen::location(&mut ctx.rng).generate_biome(),
-                    ["Desert", "Sands", "Sandsea", "Drifts", "Dunes", "Sandfield"]
-                        .choose(&mut ctx.rng)
-                        .unwrap()
+                    NameGen::location(&mut ctx.rng).generate_desert_engl(),
+                    [
+                        "Desert", "Sands", "Sandsea", "Drifts", "Dunes", "Droughts", "Flats",
+                    ]
+                    .choose(&mut ctx.rng)
+                    .unwrap()
                 )),
                 common::terrain::BiomeKind::Swamp if biome.1.len() as u32 > 750 => Some(format!(
                     "{} {}",
-                    NameGen::location(&mut ctx.rng).generate_biome(),
+                    NameGen::location(&mut ctx.rng).generate_swamp_engl(),
                     [
                         "Swamp",
                         "Swamps",
@@ -609,14 +613,17 @@ impl Civs {
                         "Marshlands",
                         "Morass",
                         "Mire",
-                        "Bog"
+                        "Bog",
+                        "Wetlands",
+                        "Fen",
+                        "Moors",
                     ]
                     .choose(&mut ctx.rng)
                     .unwrap()
                 )),
                 common::terrain::BiomeKind::Jungle if biome.1.len() as u32 > 750 => Some(format!(
                     "{} {}",
-                    NameGen::location(&mut ctx.rng).generate_biome(),
+                    NameGen::location(&mut ctx.rng).generate_jungle_engl(),
                     [
                         "Jungle",
                         "Rainforest",
@@ -625,36 +632,52 @@ impl Civs {
                         "Wildwood",
                         "Tangle",
                         "Tanglewood",
-                        "Bush"
+                        "Bush",
                     ]
                     .choose(&mut ctx.rng)
                     .unwrap()
                 )),
+                common::terrain::BiomeKind::Forest if biome.1.len() as u32 > 750 => Some(format!(
+                    "{} {}",
+                    [
+                        NameGen::location(&mut ctx.rng).generate_forest_engl(),
+                        NameGen::location(&mut ctx.rng).generate_forest_custom()
+                    ]
+                    .choose(&mut ctx.rng)
+                    .unwrap(),
+                    ["Forest", "Woodlands", "Woods", "Glades", "Grove", "Weald",]
+                        .choose(&mut ctx.rng)
+                        .unwrap()
+                )),
                 common::terrain::BiomeKind::Savannah if biome.1.len() as u32 > 750 => {
                     Some(format!(
                         "{} {}",
-                        NameGen::location(&mut ctx.rng).generate_savannah(),
-                        ["Savannah", "Shrubland", "Sierra", "Prairie", "Lowlands"]
-                            .choose(&mut ctx.rng)
-                            .unwrap()
+                        NameGen::location(&mut ctx.rng).generate_savannah_engl(),
+                        [
+                            "Savannah",
+                            "Shrublands",
+                            "Sierra",
+                            "Prairie",
+                            "Lowlands",
+                            "Flats",
+                        ]
+                        .choose(&mut ctx.rng)
+                        .unwrap()
                     ))
                 },
                 common::terrain::BiomeKind::Taiga if biome.1.len() as u32 > 750 => Some(format!(
                     "{} {}",
-                    NameGen::location(&mut ctx.rng).generate_taiga(),
-                    ["Taiga", "Timberlands", "Uplands", "Highlands"]
-                        .choose(&mut ctx.rng)
-                        .unwrap()
-                )),
-                common::terrain::BiomeKind::Lake if biome.1.len() as u32 > 200 => Some(format!(
-                    "{} {}",
-                    ["Lake", "Loch"].choose(&mut ctx.rng).unwrap(),
-                    NameGen::location(&mut ctx.rng).generate()
-                )),
-                common::terrain::BiomeKind::Lake if biome.1.len() as u32 > 10 => Some(format!(
-                    "{} {}",
-                    NameGen::location(&mut ctx.rng).generate(),
-                    ["Pool", "Well", "Pond"].choose(&mut ctx.rng).unwrap()
+                    NameGen::location(&mut ctx.rng).generate_taiga_engl(),
+                    [
+                        "Forest",
+                        "Woodlands",
+                        "Woods",
+                        "Timberlands",
+                        "Highlands",
+                        "Uplands",
+                    ]
+                    .choose(&mut ctx.rng)
+                    .unwrap()
                 )),
                 _ => None,
             };
diff --git a/world/src/site/namegen.rs b/world/src/site/namegen.rs
index 404323edcd..2b64739194 100644
--- a/world/src/site/namegen.rs
+++ b/world/src/site/namegen.rs
@@ -53,6 +53,8 @@ impl<'a, R: Rng> NameGen<'a, R> {
             .collect()
     }
 
+    // biome naming
+    // generic
     pub fn generate_biome(self) -> String {
         let cons = vec![
             "b", "d", "f", "g", "h", "k", "l", "m", "n", "s", "t", "w", "br", "dr", "gr", "gh",
@@ -91,7 +93,8 @@ impl<'a, R: Rng> NameGen<'a, R> {
             .collect()
     }
 
-    fn generate_from_parts(&mut self, start: &[&str], end: &[&str]) -> String {
+    // biome specific options: engl / custom
+    fn generate_engl_from_parts(&mut self, start: &[&str], end: &[&str]) -> String {
         let mut name = String::new();
         name += start.choose(self.rng).unwrap();
         name += end.choose(self.rng).unwrap();
@@ -102,25 +105,29 @@ impl<'a, R: Rng> NameGen<'a, R> {
             .collect()
     }
 
-    pub fn generate_temp_forest(&mut self) -> String {
-        let start = [
-            "green", "moss", "ever", "briar", "thorn", "oak", "deep", "moon", "star", "sun",
-            "bright", "glare", "fair", "calm", "mistral", "whisper", "clover", "hollow", "spring",
-            "morrow", "dim", "dusk", "dawn", "night", "shimmer", "silver", "gold", "fern", "quiet",
-            "still", "gleam", "wild", "blind", "swift", "gnarl", "flutter", "silent", "honey",
-            "bramble", "rose", "aspen",
-        ];
-        let end = [
-            "root", "bark", "log", "brook", "well", "shire", "leaf", "more", "bole", "heart",
-            "song", "dew", "bough", "path", "wind", "breeze", "light", "branch", "bloom", "vale",
-            "glen", "rest", "shade", "fall", "sward", "shrub", "bush", "grasp", "grip", "gale",
-            "crawl", "run", "shadow", "rise", "glow", "wish", "will", "walk", "wander", "wake",
-            "eye", "blossom", "sprout", "barb",
-        ];
-        self.generate_from_parts(&start, &end)
+    fn generate_custom_from_parts(
+        &mut self,
+        start: &[&str],
+        middle: &[&str],
+        vowel: &[&str],
+        end: &[&str],
+    ) -> String {
+        let mut name = String::new();
+
+        name += start.choose(self.rng).unwrap();
+        for _ in 0..self.approx_syllables.saturating_sub(2) {
+            name += vowel.choose(self.rng).unwrap();
+            name += middle.choose(self.rng).unwrap();
+        }
+        name += end.choose(self.rng).unwrap();
+
+        name.chars()
+            .enumerate()
+            .map(|(i, c)| if i == 0 { c.to_ascii_uppercase() } else { c })
+            .collect()
     }
 
-    pub fn generate_grassland(&mut self) -> String {
+    pub fn generate_grassland_engl(&mut self) -> String {
         let start = [
             "green", "heather", "flower", "blue", "yellow", "vast", "moon", "star", "sun",
             "bright", "fair", "calm", "mistral", "whisper", "clover", "sooth", "spring", "morrow",
@@ -135,15 +142,163 @@ impl<'a, R: Rng> NameGen<'a, R> {
             "rove", "brew", "rise", "glow", "wish", "will", "walk", "wander", "wake", "sky",
             "burrow", "cross", "roam",
         ];
-        self.generate_from_parts(&start, &end)
+        self.generate_engl_from_parts(&start, &end)
     }
 
-    pub fn generate_savannah(&mut self) -> String {
+    pub fn generate_ocean_engl(&mut self) -> String {
+        let start = [
+            "dark", "murk", "shimmer", "glimmer", "spirit", "moon", "dead", "bane", "salt",
+            "brine", "glitter", "thunder", "pale", "wail", "star", "dim", "azure", "sky", "rage",
+            "ripple", "gloom", "sun", "gleam", "void", "storm", "death", "silver", "dread",
+            "sorrow", "grim", "spirit",
+        ];
+        let end = [
+            "wave", "shell", "wind", "breeze", "gale", "crash", "grip", "fog", "mirror", "whirl",
+            "whorl", "stream", "current", "drift", "light", "shine", "haze", "tear", "maw", "fang",
+            "surf", "tide", "rush", "surge", "glow", "drop", "drag", "swell", "scale", "song",
+            "shroud", "grasp", "mist",
+        ];
+        self.generate_engl_from_parts(&start, &end)
+    }
+
+    pub fn generate_mountain_engl(&mut self) -> String {
+        let start = [
+            "white", "frost", "ever", "pale", "hoar", "cold", "chill", "shiver", "bitter",
+            "glimmer", "winter", "algor", "grey", "dragon", "thunder", "pallid", "death", "spirit",
+            "crystal", "shimmer", "silver", "grizzle", "quiet", "still", "high", "blind", "silent",
+            "lost", "somber", "silent", "sharp", "somber", "sharp", "rime", "ice", "spear",
+            "hammer", "sword", "war", "sky", "heaven", "dread",
+        ];
+        let end = [
+            "cloud", "veil", "shroud", "fang", "horn", "bite", "more", "howl", "heart", "song",
+            "scream", "draft", "path", "wind", "breeze", "wail", "crag", "bellow", "breach",
+            "rift", "chasm", "climb", "fall", "rise", "grasp", "grip", "gale", "summit", "shard",
+            "pierce", "crush", "shard", "clash", "wish", "will", "wake", "storm", "blade", "hold",
+            "reach", "maw", "lock", "gust", "stone", "fury", "rage", "jaw", "gorge", "clove",
+        ];
+        self.generate_engl_from_parts(&start, &end)
+    }
+
+    pub fn generate_snowland_engl(&mut self) -> String {
+        let start = [
+            "white", "frost", "ever", "pale", "hoar", "cold", "chill", "shiver", "bitter",
+            "glimmer", "winter", "algor", "grey", "ghost", "pearl", "pallid", "spectre", "spirit",
+            "crystal", "shimmer", "silver", "grizzle", "quiet", "still", "wild", "blind", "silent",
+            "lost", "somber", "sleet", "silent", "sharp", "somber", "sleet", "sharp", "rime",
+            "ice",
+        ];
+        let end = [
+            "wood", "veil", "shroud", "fang", "horn", "bite", "more", "howl", "heart", "song",
+            "scream", "draft", "path", "wind", "breeze", "wail", "growl", "bellow", "pine", "roam",
+            "rest", "shade", "fall", "fir", "grasp", "grip", "gale", "hunt", "run", "shadow",
+            "hill", "shard", "blood", "wish", "will", "walk", "wander", "wake", "storm", "blade",
+            "hold", "reach", "maw",
+        ];
+        self.generate_engl_from_parts(&start, &end)
+    }
+
+    pub fn generate_desert_engl(&mut self) -> String {
+        let start = [
+            "dry", "sun", "bright", "death", "dread", "sizzle", "scourge", "dearth", "dust",
+            "gold", "amber", "gleam", "dead", "swelter", "arid", "balm", "parch", "demon",
+            "scorch", "sear", "gold", "simmer", "doom", "torrid", "drake", "devil", "spirit",
+            "soul", "singe", "heat", "torch", "bone", "broil", "dragon", "shrivel", "sorrow",
+        ];
+        let end = [
+            "swarm", "claw", "curse", "quill", "spell", "bite", "thorn", "bane", "grasp", "storm",
+            "flare", "wind", "breeze", "howl", "reach", "flow", "sting", "sting", "fang", "blast",
+            "veil", "scale", "glare", "gaze", "skull", "prickle", "reach", "needle", "void",
+            "rise", "maw", "raze", "mirage", "glow", "wander", "roam", "breath", "shard", "scar",
+            "lurk", "cross", "stone", "flash", "dance", "burn", "blaze", "fury", "wound",
+            "blister", "mark", "waste", "blood", "rock", "grip", "blight",
+        ];
+        self.generate_engl_from_parts(&start, &end)
+    }
+
+    pub fn generate_swamp_engl(&mut self) -> String {
+        let start = [
+            "green", "moss", "deep", "moon", "haze", "drizzle", "mizzle", "rain", "bracken",
+            "hollow", "mist", "fog", "haze", "tear", "mud", "lost", "spirit", "venom", "glum",
+            "murk", "dim", "dusk", "night", "quiet", "dark", "brume", "rot", "drench", "sullen",
+            "still", "gleam", "wild", "blind", "gnarl", "silent", "dead", "rust", "soul", "gloom",
+            "bramble", "briar", "thorn", "earth", "wither", "tangle", "twist", "fear", "slither",
+        ];
+        let end = [
+            "root", "bark", "vine", "brook", "well", "veil", "mantle", "drop", "fang", "beck",
+            "bough", "vale", "whisper", "shroud", "cloak", "muck", "claw", "wane", "call", "glen",
+            "rest", "shade", "fall", "grasp", "grip", "water", "glare", "swarm", "creek", "crawl",
+            "shadow", "glow", "wood", "wander", "river", "pool", "sting", "shriek", "barb", "silt",
+            "clay", "pond", "gorse", "burr", "blight", "wisp", "scale", "rill",
+        ];
+        self.generate_engl_from_parts(&start, &end)
+    }
+
+    pub fn generate_jungle_engl(&mut self) -> String {
+        let start = [
+            "green", "ever", "briar", "thorn", "deep", "sun", "glare", "tangle", "strangle",
+            "twist", "dim", "dark", "shade", "savage", "lost", "mist", "shadow", "red", "scarlet",
+            "fog", "fern", "quiet", "gleam", "wild", "blind", "swift", "gnarl", "venom", "spirit",
+            "dread", "wonder", "drizzle", "coil", "snarl", "skein", "snare", "murk", "moss",
+            "slither",
+        ];
+        let end = [
+            "root", "bark", "vine", "leaf", "more", "bole", "heart", "song", "climb", "talon",
+            "bough", "breeze", "light", "branch", "bloom", "vale", "swarm", "prowl", "fang",
+            "horn", "fall", "bush", "grasp", "grip", "crawl", "run", "sting", "hunt", "pride",
+            "veil", "shroud", "rise", "glow", "will", "wander", "wake", "blossom", "barb", "scale",
+            "claw", "catch", "plume", "dance", "maw", "roar", "howl", "shriek", "reach", "drench",
+            "flower", "snag",
+        ];
+        self.generate_engl_from_parts(&start, &end)
+    }
+
+    pub fn generate_forest_engl(&mut self) -> String {
+        let start = [
+            "green", "moss", "ever", "briar", "thorn", "oak", "deep", "moon", "star", "sun",
+            "bright", "glare", "fair", "calm", "mistral", "whisper", "clover", "hollow", "spring",
+            "morrow", "dim", "dusk", "dawn", "night", "shimmer", "silver", "gold", "fern", "quiet",
+            "still", "gleam", "wild", "blind", "swift", "gnarl", "flutter", "silent", "honey",
+            "bramble", "rose", "aspen",
+        ];
+        let end = [
+            "root", "bark", "log", "brook", "well", "shire", "leaf", "more", "bole", "heart",
+            "song", "dew", "bough", "path", "wind", "breeze", "light", "branch", "bloom", "vale",
+            "glen", "rest", "shade", "fall", "sward", "shrub", "bush", "grasp", "grip", "gale",
+            "crawl", "run", "shadow", "rise", "glow", "wish", "will", "walk", "wander", "wake",
+            "eye", "blossom", "sprout", "barb",
+        ];
+        self.generate_engl_from_parts(&start, &end)
+    }
+
+    pub fn generate_forest_custom(&mut self) -> String {
+        let cons = vec![
+            "d", "f", "h", "l", "m", "n", "r", "s", "t", "w", "v", "z", "st", "th", "thr", "str",
+            "vr", "wr", "an", "and", "ald", "ath", "as", "all", "amm", "an", "az", "en", "end",
+            "eld", "eldr", "es", "ell", "aldr", "astr", "estr", "on", "ond",
+        ];
+        let start = cons.clone();
+        let middle = vec![
+            "th", "d", "dr", "sl", "sm", "rw", "rv", "l", "ll", "m", "mm", "n", "nn", "nd", "ndr",
+            "thr", "nth", "ln", "lm", "lz", "nz", "nr", "str", "sth", "ld", "rm", "sd", "rn", "ss",
+            "sn", "lw", "lv", "th", "rw", "nw", "r", "rth", "rz",
+        ];
+        let vowel = vec!["o", "e", "a", "u", "ae"];
+        let end = vec![
+            "anir", "enir", "elen", "alen", "ezen", "azen", "yn", "andir", "endir", "ond", "alar",
+            "ales", "eles", "arain", "alain", "anuin", "athuin", "aruin", "yr", "ethuin", "eruin",
+            "athul", "edor", "edes", "edus", "inyr", "eden", "azar", "atiel", "etiel", "etien",
+            "eties", "aties", "aduil", "eduil", "eduin", "aduin", "assil", "iryl", "aryl", "anor",
+            "anes", "en", "es", "ys",
+        ];
+        self.generate_custom_from_parts(&start, &middle, &vowel, &end)
+    }
+
+    pub fn generate_savannah_engl(&mut self) -> String {
         let start = [
             "red", "pride", "dry", "copper", "vast", "war", "star", "sun", "bright", "blood",
             "dawn", "shimmer", "gold", "amber", "gleam", "wild", "rust", "fire", "earth", "spirit",
-            "bronze", "broad", "scorch", "sear", "gold", "prowl", "marl", "gleam", "rage", "ghost",
-            "soul", "specter", "scald", "singe", "heat", "torch", "rite", "bone", "petal",
+            "bronze", "broad", "scorch", "sear", "gold", "prowl", "marl", "rage", "ghost", "soul",
+            "specter", "scald", "singe", "heat", "torch", "rite", "bone",
         ];
         let end = [
             "dust", "grass", "swarm", "more", "heart", "song", "claw", "fang", "hoof", "foot",
@@ -152,16 +307,16 @@ impl<'a, R: Rng> NameGen<'a, R> {
             "gaze", "wallow", "brew", "rise", "glow", "wade", "wander", "wake", "sky", "roam",
             "breath", "shard", "scar", "lurk", "hill", "blaze", "fury", "hunt",
         ];
-        self.generate_from_parts(&start, &end)
+        self.generate_engl_from_parts(&start, &end)
     }
 
-    pub fn generate_taiga(&mut self) -> String {
+    pub fn generate_taiga_engl(&mut self) -> String {
         let start = [
             "green", "blue", "ever", "pale", "needle", "cold", "moon", "star", "chill", "shiver",
             "bitter", "fair", "calm", "mistral", "whisper", "grey", "hollow", "morrow", "dim",
             "dusk", "dawn", "night", "shimmer", "silver", "iron", "quill", "grizzle", "quiet",
             "still", "wild", "blind", "silent", "somber", "sleet", "silent", "sharp", "somber",
-            "sleet", "silent", "sharp", "rime", "drizzle", "resin",
+            "sleet", "sharp", "rime", "drizzle", "resin",
         ];
         let end = [
             "root", "bark", "log", "brook", "well", "shire", "more", "bole", "heart", "song",
@@ -170,6 +325,51 @@ impl<'a, R: Rng> NameGen<'a, R> {
             "hill", "shadow", "larch", "rise", "bite", "wish", "will", "walk", "wander", "wake",
             "stone", "howl", "moss",
         ];
-        self.generate_from_parts(&start, &end)
+        self.generate_engl_from_parts(&start, &end)
+    }
+
+    // themes / sites
+    // greek/latin inspired location names for danari
+    pub fn generate_danari(self) -> String {
+        let cons = vec![
+            "d", "ph", "r", "st", "t", "s", "p", "th", "br", "tr", "m", "k", "cr", "phr", "dr",
+            "pl", "ch", "l", "ap", "akr", "ak", "ar", "ath", "asp", "al", "aph", "aphr", "oph",
+            "or", "ok", "on", "od", "oth", "om", "ep", "er", "em", "eph", "eth", "yps", "yph",
+            "ach", "amph", "yp", "ik", "is", "iph", "ith", "pr", "as", "asph", "ps", "b", "n", "z",
+            "x", "kr", "kt", "cht", "chr", "thr", "dr", "pr", "pl", "h", "in", "g", "sph",
+        ];
+        let mut start = cons.clone();
+        start.extend(vec![
+            "kr", "tr", "str", "rk", "st", "n", "r", "ph", "phr", "ch", "x", "d", "l", "kt", "pr",
+            "ll", "pp", "ss", "th", "mm", "s", "t", "g", "mn", "rg", "b", "p", "ps", "kl", "dr",
+            "mp", "sp", "cht", "lph",
+        ]);
+        let mut middle = cons.clone();
+        middle.extend(vec!["tt"]);
+        let vowel = vec![
+            "o", "e", "a", "i", "y", "eo", "ae", "ea", "oi", "io", "ia", "aeo",
+        ];
+        let end = vec![
+            "ilia", "ilios", "os", "oros", "ophos", "elos", "ethos", "athos", "yros", "a", "ares",
+            "aros", "olis", "ophis", "era", "ara", "ora", "antis", "entis", "ead", "aeon", "on",
+            "eon", "oron", "ena", "is", "as", "eris", "eras", "inis", "aros", "in", "orea", "isis",
+            "okles", "akles", "ilion", "anos", "akos", "akon", "enon", "es", "aros", "ikron",
+            "orea", "area", "ilon", "ilos", "aelos", "yron", "iron", "adalos", "anon", "ix", "ox",
+            "alea", "atheas", "eas", "eos", "yros", "ophon",
+        ];
+
+        let mut name = String::new();
+
+        name += start.choose(self.rng).unwrap();
+        for _ in 0..self.approx_syllables.saturating_sub(2) {
+            name += vowel.choose(self.rng).unwrap();
+            name += middle.choose(self.rng).unwrap();
+        }
+        name += end.choose(self.rng).unwrap();
+
+        name.chars()
+            .enumerate()
+            .map(|(i, c)| if i == 0 { c.to_ascii_uppercase() } else { c })
+            .collect()
     }
 }