<?xml version="1.0" encoding="UTF-8"?><rss version="2.0"
	xmlns:content="http://purl.org/rss/1.0/modules/content/"
	xmlns:wfw="http://wellformedweb.org/CommentAPI/"
	xmlns:dc="http://purl.org/dc/elements/1.1/"
	xmlns:atom="http://www.w3.org/2005/Atom"
	xmlns:sy="http://purl.org/rss/1.0/modules/syndication/"
	xmlns:slash="http://purl.org/rss/1.0/modules/slash/"
	>

<channel>
	<title>Name Generators Archives - Free Online Tools - Imediacto</title>
	<atom:link href="https://imediacto.com/category/tools/name-generators/feed/" rel="self" type="application/rss+xml" />
	<link>https://imediacto.com/category/tools/name-generators/</link>
	<description>Free Online Tool Set for Text and HTML</description>
	<lastBuildDate>Tue, 09 Jun 2026 09:43:01 +0000</lastBuildDate>
	<language>en-US</language>
	<sy:updatePeriod>
	hourly	</sy:updatePeriod>
	<sy:updateFrequency>
	1	</sy:updateFrequency>
	<generator>https://wordpress.org/?v=7.0.1</generator>

<image>
	<url>https://imediacto.com/wp-content/uploads/2020/04/cropped-favicon-32x32.png</url>
	<title>Name Generators Archives - Free Online Tools - Imediacto</title>
	<link>https://imediacto.com/category/tools/name-generators/</link>
	<width>32</width>
	<height>32</height>
</image> 
	<item>
		<title>Random Name Generator</title>
		<link>https://imediacto.com/tools/name-generators/random-name-generator/</link>
					<comments>https://imediacto.com/tools/name-generators/random-name-generator/#respond</comments>
		
		<dc:creator><![CDATA[Dante]]></dc:creator>
		<pubDate>Tue, 09 Jun 2026 09:43:01 +0000</pubDate>
				<category><![CDATA[Name Generators]]></category>
		<category><![CDATA[Random Name Generator]]></category>
		<guid isPermaLink="false">https://imediacto.com/?p=411</guid>

					<description><![CDATA[<p>Random Name Generator is a free online tool to generate realistic human names by country, gender, style, and name structure. Export as TXT, JSON, CSV, and HTML list.</p>
<p>The post <a href="https://imediacto.com/tools/name-generators/random-name-generator/">Random Name Generator</a> appeared first on <a href="https://imediacto.com">Free Online Tools - Imediacto</a>.</p>
]]></description>
										<content:encoded><![CDATA[<p><div class="boot random-name-generator">
            <div class="row mb-3">
                <div class="col-sm-12">
                    <h2>Generate Realistic Names by Country</h2>
                    <p>
                        <strong>Random Name Generator</strong> is a clean and practical online tool to create realistic
                        names with country, gender, style, and structure filters. You can also add optional metadata
                        such as age, nationality, locality, and language, then export results as TXT, JSON, CSV, and
                        HTML lists.
                    </p>
                </div>
            </div>

            <div class="tool-panel">
                <h3 class="step-title">Step 1) Select one or more countries</h3>
                <p class="step-help">Use presets for faster selection, or click countries manually.</p>

                <div class="preset-row">
                    <button class="preset-btn" type="button" onclick="applyPreset('western')">Western preset</button>
                    <button class="preset-btn" type="button" onclick="applyPreset('latin')">Latin preset</button>
                    <button class="preset-btn" type="button" onclick="applyPreset('asian')">Asian preset</button>
                    <button class="preset-btn" type="button" onclick="applyPreset('nordic')">Nordic preset</button>
                    <button class="preset-btn" type="button" onclick="clearCountrySelection()">Clear countries</button>
                </div>

                <div id="countriesGrid" class="countries-grid"></div>
                <div id="selectedCount" class="counter">0 countries selected</div>
                <div id="validationMessage" class="error-inline none"></div>
            </div>

            <div class="tool-panel">
                <h3 class="step-title">Step 2) Configure generation</h3>
                <p class="step-help">Choose structure, gender, style and quantity. Defaults are optimized for fast use.</p>

                <div class="controls-grid">
                    <div>
                        <label for="nameStructure"><strong>Name structure</strong></label>
                        <div class="radio-group">
                            <label><input type="radio" name="nameStructure" value="firstOnly">First name only</label>
                            <label><input type="radio" name="nameStructure" value="firstOne" checked>First + 1 surname</label>
                            <label><input type="radio" name="nameStructure" value="firstTwo">First + 2 surnames</label>
                            <label><input type="radio" name="nameStructure" value="firstFour">First + 4 surnames</label>
                        </div>
                    </div>

                    <div>
                        <label for="gender"><strong>Gender</strong></label>
                        <div class="radio-group">
                            <label><input type="radio" name="gender" value="male">Male</label>
                            <label><input type="radio" name="gender" value="female">Female</label>
                            <label><input type="radio" name="gender" value="both" checked>Both</label>
                            <label><input type="checkbox" id="includeUnisex">Include ambiguous names</label>
                        </div>
                    </div>

                    <div>
                        <label for="nameStyle"><strong>Name style</strong></label>
                        <div class="radio-group">
                            <label><input type="radio" name="nameStyle" value="modern">Modern</label>
                            <label><input type="radio" name="nameStyle" value="classic">Classic</label>
                            <label><input type="radio" name="nameStyle" value="traditional">Traditional</label>
                            <label><input type="radio" name="nameStyle" value="mixed" checked>Mixed</label>
                        </div>
                    </div>

                    <div>
                        <label for="quantity"><strong>Names quantity</strong></label>
                        <input type="number" id="quantity" min="1" max="100" value="20">
                        <p class="step-help">Min 1, max 100. For multiple countries, total is distributed automatically.</p>
                    </div>
                </div>
            </div>

            <div class="tool-panel">
                <h3 class="step-title">Step 3) Select extra output fields (optional)</h3>
                <p class="step-help">These fields appear in results and are included in JSON, CSV, and HTML exports.</p>

                <div class="radio-group">
                    <label class="extra-field"><input type="checkbox" class="extra-checkbox" value="age">Age</label>
                    <label class="extra-field"><input type="checkbox" class="extra-checkbox" value="sex">Sex</label>
                    <label class="extra-field"><input type="checkbox" class="extra-checkbox" value="country">Country</label>
                    <label class="extra-field"><input type="checkbox" class="extra-checkbox" value="nationality">Nationality</label>
                    <label class="extra-field"><input type="checkbox" class="extra-checkbox" value="locality">Locality</label>
                    <label class="extra-field"><input type="checkbox" class="extra-checkbox" value="language">Language</label>
                    <label class="extra-field"><input type="checkbox" class="extra-checkbox" value="popularity">Popularity</label>
                </div>

                <div class="actions">
                    <button id="generateButton" class="btn btn-success" onclick="generateNames()"><i class="fa fa-magic"></i> Generate names</button>
                    <button class="btn btn-light" onclick="clearResults()"><i class="fa fa-eraser"></i> Clear output</button>
                </div>

                <div id="emptyState" class="empty-state">
                    Select at least one country, keep default options if you want, and click Generate names.
                </div>

                <div id="summary" class="summary none"></div>
                <div id="stats" class="stats none"></div>

                <div id="resultTools" class="result-tools none">
                    <button class="soft" onclick="copyToClipboard('plainOutput', 'checkCopy')" title="Copy output to clipboard"><i class="fa fa-copy"></i> Copy</button>
                    <button class="soft" onclick="downloadTxt()" title="Download TXT"><i class="fa fa-download"></i> TXT</button>
                    <button class="soft" onclick="downloadJson()" title="Download JSON"><i class="fa fa-download"></i> JSON</button>
                    <button class="soft" onclick="downloadCsv()" title="Download CSV"><i class="fa fa-download"></i> CSV</button>
                    <button class="soft" onclick="downloadHtmlList('ol')" title="Download ordered HTML list"><i class="fa fa-download"></i> HTML OL</button>
                    <button class="soft" onclick="downloadHtmlList('ul')" title="Download unordered HTML list"><i class="fa fa-download"></i> HTML UL</button>
                    <div id="checkCopy" class="check none"></div>
                </div>

                <div id="resultsCards" class="results-cards"></div>
                <ol id="resultsList" class="results-list none"></ol>
                <div id="plainOutput" class="none"></div>
            </div>

            <hr>

            <div class="more-notes entry-content">
                <h2>What is a Random Name Generator?</h2>
                <p>
                    A random name generator creates realistic person names for scripts, books, NPC creation, test data,
                    game rosters, and creative brainstorming. This tool focuses on country-aware naming structures.
                </p>

                <h2>Why country-based names improve realism</h2>
                <p>
                    Names from different countries follow different first-name and surname patterns. Choosing country,
                    style, and structure helps generate names that feel more authentic to a region and language.
                </p>

                <h2>How the style filter works</h2>
                <p>
                    Use <strong>modern</strong> for contemporary names, <strong>classic</strong> for historically common
                    names, and <strong>traditional</strong> for names with stronger cultural roots. Mixed combines all styles.
                </p>

                <h2>Top 20 names by country</h2>
                <h3>USA</h3>
                <p>James, Michael, William, Alexander, Benjamin, Emma, Olivia, Sophia, Charlotte, Amelia, Mason, Ethan, Harper, Evelyn, Lucas, Henry, Scarlett, Zoe, Jack, Ella.</p>
                <h3>UK</h3>
                <p>Oliver, George, Arthur, Harry, Leo, Jack, Amelia, Isla, Florence, Freya, Noah, Oscar, Archie, Ava, Ivy, Elsie, Theo, Lily, Alfie, Grace.</p>
                <h3>Spain</h3>
                <p>Alejandro, Mateo, Hugo, Daniel, Pablo, Lucia, Sofia, Martina, Carmen, Alba, Javier, Miguel, Laura, Maria, Elena, Diego, Adriana, Raul, Ines, Clara.</p>
                <h3>France</h3>
                <p>Louis, Gabriel, Jules, Arthur, Hugo, Emma, Louise, Chloe, Lea, Camille, Antoine, Paul, Sarah, Claire, Elise, Theo, Lucas, Manon, Zoe, Jeanne.</p>
                <h3>Germany</h3>
                <p>Lukas, Leon, Felix, Jonas, Max, Mia, Emma, Hannah, Lina, Sofia, Finn, Noah, Anna, Lara, Johanna, Elias, Paul, Marie, Greta, Klara.</p>
                <h3>Brazil</h3>
                <p>Joao, Pedro, Gabriel, Lucas, Mateus, Maria, Ana, Julia, Beatriz, Isabela, Rafael, Felipe, Carolina, Fernanda, Luiza, Gustavo, Thiago, Larissa, Camila, Leticia.</p>

                <h2>Frequently Asked Questions (FAQ)</h2>
                <h3>Can I use generated names in commercial projects?</h3>
                <p>Yes. You can use generated results for scripts, game prototypes, stories, and similar creative work.</p>

                <h3>How does unisex mode work?</h3>
                <p>When the ambiguous checkbox is enabled, the generator includes names commonly used across more than one gender.</p>

                <h3>Why are there multiple surname options?</h3>
                <p>Different regions use one or more surnames. This option helps adapt name output to different conventions.</p>
            </div>

            <div class="notes">
                <div class="image"></div>
                <div class="message">
                    <p>
                        Send me your feedback about this <strong>Random Name Generator</strong> and tell me if you need
                        additional countries, better locality mappings, or more export options, so I can improve this tool.
                    </p>
                    <p>
                        You can contribute with fixes and improvements on Github:
                        <a href="https://github.com/dantovsky/Imediacto-Online-Tool-Set/tree/master/tools/013-random-name-generator" target="_blank">Github >> Random Name Generator</a>.
                        Pull requests are welcome.
                    </p>
                </div>
            </div>
        </div>

        <script>
            const COUNTRY_KEYS = [
                'USA', 'UK', 'Spain', 'France', 'Germany', 'Italy', 'Brazil', 'Japan', 'India', 'Russia', 'Sweden', 'Netherlands'
            ];

            const PRESETS = {
                western: ['USA', 'UK', 'France', 'Germany', 'Netherlands'],
                latin: ['Spain', 'Italy', 'Brazil'],
                asian: ['Japan', 'India'],
                nordic: ['Sweden', 'Russia']
            };

            const selectedCountries = new Set();
            let generatedRecords = [];

            const COUNTRY_BANK = {
                USA: {
                    nationality: 'American',
                    languages: ['English'],
                    localities: ['New York', 'Los Angeles', 'Chicago', 'Austin', 'Seattle', 'Boston'],
                    male: [
                        { name: 'James', style: 'classic', popularity: 'common' },
                        { name: 'Michael', style: 'classic', popularity: 'common' },
                        { name: 'Noah', style: 'modern', popularity: 'common' },
                        { name: 'Logan', style: 'modern', popularity: 'common' },
                        { name: 'Theodore', style: 'traditional', popularity: 'rare' },
                        { name: 'Ethan', style: 'modern', popularity: 'common' }
                    ],
                    female: [
                        { name: 'Emma', style: 'classic', popularity: 'common' },
                        { name: 'Olivia', style: 'modern', popularity: 'common' },
                        { name: 'Amelia', style: 'classic', popularity: 'common' },
                        { name: 'Charlotte', style: 'traditional', popularity: 'rare' },
                        { name: 'Harper', style: 'modern', popularity: 'common' },
                        { name: 'Evelyn', style: 'classic', popularity: 'common' }
                    ],
                    unisex: [
                        { name: 'Noa', style: 'modern', popularity: 'common' },
                        { name: 'Taylor', style: 'classic', popularity: 'common' },
                        { name: 'Jordan', style: 'classic', popularity: 'common' }
                    ],
                    surnames: ['Smith', 'Johnson', 'Brown', 'Miller', 'Davis', 'Anderson', 'Moore', 'Clark']
                },
                UK: {
                    nationality: 'British',
                    languages: ['English'],
                    localities: ['London', 'Manchester', 'Liverpool', 'Bristol', 'Leeds', 'Oxford'],
                    male: [
                        { name: 'Oliver', style: 'modern', popularity: 'common' },
                        { name: 'George', style: 'classic', popularity: 'common' },
                        { name: 'Arthur', style: 'traditional', popularity: 'rare' },
                        { name: 'Harry', style: 'classic', popularity: 'common' },
                        { name: 'Leo', style: 'modern', popularity: 'common' },
                        { name: 'Alfie', style: 'traditional', popularity: 'rare' }
                    ],
                    female: [
                        { name: 'Isla', style: 'modern', popularity: 'common' },
                        { name: 'Freya', style: 'traditional', popularity: 'rare' },
                        { name: 'Amelia', style: 'classic', popularity: 'common' },
                        { name: 'Ivy', style: 'modern', popularity: 'common' },
                        { name: 'Grace', style: 'classic', popularity: 'common' },
                        { name: 'Florence', style: 'traditional', popularity: 'rare' }
                    ],
                    unisex: [
                        { name: 'Morgan', style: 'classic', popularity: 'common' },
                        { name: 'Alex', style: 'modern', popularity: 'common' },
                        { name: 'Riley', style: 'modern', popularity: 'rare' }
                    ],
                    surnames: ['Smith', 'Taylor', 'Walker', 'Wright', 'Turner', 'Carter', 'Evans', 'Foster']
                },
                Spain: {
                    nationality: 'Spanish',
                    languages: ['Spanish'],
                    localities: ['Madrid', 'Barcelona', 'Valencia', 'Seville', 'Bilbao', 'Granada'],
                    male: [
                        { name: 'Alejandro', style: 'classic', popularity: 'common' },
                        { name: 'Mateo', style: 'modern', popularity: 'common' },
                        { name: 'Hugo', style: 'modern', popularity: 'common' },
                        { name: 'Javier', style: 'traditional', popularity: 'rare' },
                        { name: 'Pablo', style: 'classic', popularity: 'common' },
                        { name: 'Miguel', style: 'traditional', popularity: 'common' }
                    ],
                    female: [
                        { name: 'Lucia', style: 'modern', popularity: 'common' },
                        { name: 'Sofia', style: 'modern', popularity: 'common' },
                        { name: 'Martina', style: 'classic', popularity: 'common' },
                        { name: 'Carmen', style: 'traditional', popularity: 'rare' },
                        { name: 'Alba', style: 'modern', popularity: 'common' },
                        { name: 'Elena', style: 'classic', popularity: 'common' }
                    ],
                    unisex: [
                        { name: 'Noa', style: 'modern', popularity: 'common' },
                        { name: 'Alexis', style: 'classic', popularity: 'rare' },
                        { name: 'Andrea', style: 'classic', popularity: 'common' }
                    ],
                    surnames: ['Garcia', 'Lopez', 'Martinez', 'Sanchez', 'Perez', 'Gomez', 'Ruiz', 'Hernandez']
                },
                France: {
                    nationality: 'French',
                    languages: ['French'],
                    localities: ['Paris', 'Lyon', 'Marseille', 'Toulouse', 'Nice', 'Bordeaux'],
                    male: [
                        { name: 'Louis', style: 'classic', popularity: 'common' },
                        { name: 'Gabriel', style: 'modern', popularity: 'common' },
                        { name: 'Jules', style: 'traditional', popularity: 'rare' },
                        { name: 'Hugo', style: 'modern', popularity: 'common' },
                        { name: 'Theo', style: 'modern', popularity: 'common' },
                        { name: 'Paul', style: 'classic', popularity: 'common' }
                    ],
                    female: [
                        { name: 'Emma', style: 'modern', popularity: 'common' },
                        { name: 'Louise', style: 'traditional', popularity: 'rare' },
                        { name: 'Chloe', style: 'classic', popularity: 'common' },
                        { name: 'Lea', style: 'modern', popularity: 'common' },
                        { name: 'Camille', style: 'classic', popularity: 'common' },
                        { name: 'Jeanne', style: 'traditional', popularity: 'rare' }
                    ],
                    unisex: [
                        { name: 'Sasha', style: 'modern', popularity: 'rare' },
                        { name: 'Claude', style: 'traditional', popularity: 'rare' },
                        { name: 'Noel', style: 'classic', popularity: 'rare' }
                    ],
                    surnames: ['Martin', 'Bernard', 'Dubois', 'Thomas', 'Robert', 'Richard', 'Petit', 'Moreau']
                },
                Germany: {
                    nationality: 'German',
                    languages: ['German'],
                    localities: ['Berlin', 'Munich', 'Hamburg', 'Cologne', 'Frankfurt', 'Stuttgart'],
                    male: [
                        { name: 'Lukas', style: 'modern', popularity: 'common' },
                        { name: 'Leon', style: 'modern', popularity: 'common' },
                        { name: 'Felix', style: 'classic', popularity: 'common' },
                        { name: 'Jonas', style: 'classic', popularity: 'common' },
                        { name: 'Maximilian', style: 'traditional', popularity: 'rare' },
                        { name: 'Finn', style: 'modern', popularity: 'common' }
                    ],
                    female: [
                        { name: 'Mia', style: 'modern', popularity: 'common' },
                        { name: 'Hannah', style: 'classic', popularity: 'common' },
                        { name: 'Sofia', style: 'modern', popularity: 'common' },
                        { name: 'Lina', style: 'modern', popularity: 'common' },
                        { name: 'Johanna', style: 'traditional', popularity: 'rare' },
                        { name: 'Klara', style: 'traditional', popularity: 'rare' }
                    ],
                    unisex: [
                        { name: 'Nico', style: 'modern', popularity: 'common' },
                        { name: 'Luca', style: 'modern', popularity: 'common' },
                        { name: 'Robin', style: 'classic', popularity: 'common' }
                    ],
                    surnames: ['Muller', 'Schmidt', 'Schneider', 'Fischer', 'Weber', 'Meyer', 'Wagner', 'Becker']
                },
                Italy: {
                    nationality: 'Italian',
                    languages: ['Italian'],
                    localities: ['Rome', 'Milan', 'Naples', 'Turin', 'Florence', 'Bologna'],
                    male: [
                        { name: 'Luca', style: 'modern', popularity: 'common' },
                        { name: 'Leonardo', style: 'classic', popularity: 'common' },
                        { name: 'Matteo', style: 'modern', popularity: 'common' },
                        { name: 'Giovanni', style: 'traditional', popularity: 'rare' },
                        { name: 'Alessandro', style: 'classic', popularity: 'common' },
                        { name: 'Marco', style: 'classic', popularity: 'common' }
                    ],
                    female: [
                        { name: 'Giulia', style: 'modern', popularity: 'common' },
                        { name: 'Sofia', style: 'modern', popularity: 'common' },
                        { name: 'Francesca', style: 'classic', popularity: 'common' },
                        { name: 'Chiara', style: 'classic', popularity: 'common' },
                        { name: 'Beatrice', style: 'traditional', popularity: 'rare' },
                        { name: 'Elena', style: 'classic', popularity: 'common' }
                    ],
                    unisex: [
                        { name: 'Andrea', style: 'classic', popularity: 'common' },
                        { name: 'Gabriele', style: 'modern', popularity: 'rare' },
                        { name: 'Lorenza', style: 'traditional', popularity: 'rare' }
                    ],
                    surnames: ['Rossi', 'Russo', 'Ferrari', 'Esposito', 'Bianchi', 'Romano', 'Gallo', 'Costa']
                },
                Brazil: {
                    nationality: 'Brazilian',
                    languages: ['Portuguese'],
                    localities: ['Sao Paulo', 'Rio de Janeiro', 'Belo Horizonte', 'Curitiba', 'Salvador', 'Recife'],
                    male: [
                        { name: 'Joao', style: 'traditional', popularity: 'common' },
                        { name: 'Pedro', style: 'classic', popularity: 'common' },
                        { name: 'Gabriel', style: 'modern', popularity: 'common' },
                        { name: 'Lucas', style: 'modern', popularity: 'common' },
                        { name: 'Rafael', style: 'classic', popularity: 'common' },
                        { name: 'Thiago', style: 'traditional', popularity: 'rare' }
                    ],
                    female: [
                        { name: 'Maria', style: 'traditional', popularity: 'common' },
                        { name: 'Ana', style: 'classic', popularity: 'common' },
                        { name: 'Julia', style: 'modern', popularity: 'common' },
                        { name: 'Beatriz', style: 'classic', popularity: 'common' },
                        { name: 'Isabela', style: 'modern', popularity: 'common' },
                        { name: 'Luiza', style: 'modern', popularity: 'common' }
                    ],
                    unisex: [
                        { name: 'Noa', style: 'modern', popularity: 'rare' },
                        { name: 'Alex', style: 'modern', popularity: 'common' },
                        { name: 'Ariel', style: 'classic', popularity: 'rare' }
                    ],
                    surnames: ['Silva', 'Santos', 'Oliveira', 'Souza', 'Lima', 'Costa', 'Pereira', 'Almeida']
                },
                Japan: {
                    nationality: 'Japanese',
                    languages: ['Japanese'],
                    localities: ['Tokyo', 'Osaka', 'Kyoto', 'Sapporo', 'Fukuoka', 'Yokohama'],
                    male: [
                        { name: 'Haruto', style: 'modern', popularity: 'common' },
                        { name: 'Ren', style: 'modern', popularity: 'common' },
                        { name: 'Yuto', style: 'modern', popularity: 'common' },
                        { name: 'Takumi', style: 'classic', popularity: 'common' },
                        { name: 'Daiki', style: 'traditional', popularity: 'rare' },
                        { name: 'Kenta', style: 'classic', popularity: 'common' }
                    ],
                    female: [
                        { name: 'Yui', style: 'modern', popularity: 'common' },
                        { name: 'Aoi', style: 'modern', popularity: 'common' },
                        { name: 'Sakura', style: 'traditional', popularity: 'common' },
                        { name: 'Hina', style: 'modern', popularity: 'common' },
                        { name: 'Mio', style: 'classic', popularity: 'common' },
                        { name: 'Akari', style: 'modern', popularity: 'common' }
                    ],
                    unisex: [
                        { name: 'Haru', style: 'modern', popularity: 'common' },
                        { name: 'Rei', style: 'classic', popularity: 'common' },
                        { name: 'Kaoru', style: 'traditional', popularity: 'rare' }
                    ],
                    surnames: ['Sato', 'Suzuki', 'Takahashi', 'Tanaka', 'Watanabe', 'Ito', 'Yamamoto', 'Nakamura']
                },
                India: {
                    nationality: 'Indian',
                    languages: ['Hindi', 'English'],
                    localities: ['Mumbai', 'Delhi', 'Bangalore', 'Hyderabad', 'Pune', 'Chennai'],
                    male: [
                        { name: 'Aarav', style: 'modern', popularity: 'common' },
                        { name: 'Vihaan', style: 'modern', popularity: 'common' },
                        { name: 'Arjun', style: 'classic', popularity: 'common' },
                        { name: 'Rahul', style: 'classic', popularity: 'common' },
                        { name: 'Siddharth', style: 'traditional', popularity: 'rare' },
                        { name: 'Karan', style: 'modern', popularity: 'common' }
                    ],
                    female: [
                        { name: 'Anaya', style: 'modern', popularity: 'common' },
                        { name: 'Diya', style: 'modern', popularity: 'common' },
                        { name: 'Priya', style: 'classic', popularity: 'common' },
                        { name: 'Aisha', style: 'classic', popularity: 'common' },
                        { name: 'Meera', style: 'traditional', popularity: 'rare' },
                        { name: 'Kavya', style: 'modern', popularity: 'common' }
                    ],
                    unisex: [
                        { name: 'Aadi', style: 'modern', popularity: 'rare' },
                        { name: 'Sam', style: 'modern', popularity: 'common' },
                        { name: 'Krishna', style: 'traditional', popularity: 'rare' }
                    ],
                    surnames: ['Sharma', 'Patel', 'Singh', 'Gupta', 'Kumar', 'Verma', 'Reddy', 'Nair']
                },
                Russia: {
                    nationality: 'Russian',
                    languages: ['Russian'],
                    localities: ['Moscow', 'Saint Petersburg', 'Kazan', 'Novosibirsk', 'Sochi', 'Samara'],
                    male: [
                        { name: 'Ivan', style: 'traditional', popularity: 'common' },
                        { name: 'Nikolai', style: 'classic', popularity: 'common' },
                        { name: 'Dmitri', style: 'classic', popularity: 'common' },
                        { name: 'Alexei', style: 'classic', popularity: 'common' },
                        { name: 'Mikhail', style: 'traditional', popularity: 'common' },
                        { name: 'Artem', style: 'modern', popularity: 'common' }
                    ],
                    female: [
                        { name: 'Anna', style: 'classic', popularity: 'common' },
                        { name: 'Sofia', style: 'modern', popularity: 'common' },
                        { name: 'Elena', style: 'classic', popularity: 'common' },
                        { name: 'Irina', style: 'traditional', popularity: 'rare' },
                        { name: 'Ksenia', style: 'modern', popularity: 'rare' },
                        { name: 'Maria', style: 'classic', popularity: 'common' }
                    ],
                    unisex: [
                        { name: 'Sasha', style: 'classic', popularity: 'common' },
                        { name: 'Zhenya', style: 'traditional', popularity: 'rare' },
                        { name: 'Nikita', style: 'traditional', popularity: 'common' }
                    ],
                    surnames: ['Ivanov', 'Smirnov', 'Kuznetsov', 'Popov', 'Sokolov', 'Lebedev', 'Morozov', 'Volkov']
                },
                Sweden: {
                    nationality: 'Swedish',
                    languages: ['Swedish'],
                    localities: ['Stockholm', 'Gothenburg', 'Malmo', 'Uppsala', 'Lund', 'Vasteras'],
                    male: [
                        { name: 'Liam', style: 'modern', popularity: 'common' },
                        { name: 'Noah', style: 'modern', popularity: 'common' },
                        { name: 'Erik', style: 'traditional', popularity: 'common' },
                        { name: 'Oscar', style: 'classic', popularity: 'common' },
                        { name: 'Axel', style: 'traditional', popularity: 'rare' },
                        { name: 'Elias', style: 'modern', popularity: 'common' }
                    ],
                    female: [
                        { name: 'Alice', style: 'classic', popularity: 'common' },
                        { name: 'Maja', style: 'modern', popularity: 'common' },
                        { name: 'Elsa', style: 'traditional', popularity: 'rare' },
                        { name: 'Linn', style: 'classic', popularity: 'rare' },
                        { name: 'Freja', style: 'traditional', popularity: 'common' },
                        { name: 'Nora', style: 'modern', popularity: 'common' }
                    ],
                    unisex: [
                        { name: 'Kim', style: 'classic', popularity: 'common' },
                        { name: 'Robin', style: 'modern', popularity: 'common' },
                        { name: 'Alex', style: 'modern', popularity: 'common' }
                    ],
                    surnames: ['Andersson', 'Johansson', 'Karlsson', 'Nilsson', 'Eriksson', 'Larsson', 'Olsson', 'Persson']
                },
                Netherlands: {
                    nationality: 'Dutch',
                    languages: ['Dutch', 'English'],
                    localities: ['Amsterdam', 'Rotterdam', 'Utrecht', 'Eindhoven', 'The Hague', 'Groningen'],
                    male: [
                        { name: 'Daan', style: 'modern', popularity: 'common' },
                        { name: 'Lucas', style: 'modern', popularity: 'common' },
                        { name: 'Milan', style: 'modern', popularity: 'common' },
                        { name: 'Pieter', style: 'traditional', popularity: 'rare' },
                        { name: 'Jasper', style: 'classic', popularity: 'common' },
                        { name: 'Bram', style: 'traditional', popularity: 'common' }
                    ],
                    female: [
                        { name: 'Emma', style: 'modern', popularity: 'common' },
                        { name: 'Julia', style: 'classic', popularity: 'common' },
                        { name: 'Sophie', style: 'modern', popularity: 'common' },
                        { name: 'Lotte', style: 'traditional', popularity: 'rare' },
                        { name: 'Mila', style: 'modern', popularity: 'common' },
                        { name: 'Eva', style: 'classic', popularity: 'common' }
                    ],
                    unisex: [
                        { name: 'Sam', style: 'modern', popularity: 'common' },
                        { name: 'Noa', style: 'modern', popularity: 'common' },
                        { name: 'Robin', style: 'classic', popularity: 'common' }
                    ],
                    surnames: ['De Jong', 'Jansen', 'De Vries', 'Van den Berg', 'Van Dijk', 'Bakker', 'Janssen', 'Visser']
                }
            };

            function createCountryPills() {
                const grid = document.getElementById('countriesGrid');
                grid.innerHTML = '';
                COUNTRY_KEYS.forEach((country) => {
                    const button = document.createElement('button');
                    button.type = 'button';
                    button.className = 'country-pill';
                    button.textContent = country;
                    button.setAttribute('data-country', country);
                    button.addEventListener('click', function () {
                        toggleCountry(country, button);
                    });
                    grid.appendChild(button);
                });
            }

            function toggleCountry(country, button) {
                if (selectedCountries.has(country)) {
                    selectedCountries.delete(country);
                    button.classList.remove('active');
                } else {
                    selectedCountries.add(country);
                    button.classList.add('active');
                }
                syncCountryCount();
            }

            function syncCountryCount() {
                const count = selectedCountries.size;
                document.getElementById('selectedCount').textContent = count + (count === 1 ? ' country selected' : ' countries selected');
                document.getElementById('validationMessage').classList.add('none');
                document.getElementById('validationMessage').textContent = '';
            }

            function applyPreset(type) {
                clearCountrySelection(true);
                PRESETS[type].forEach((country) => {
                    selectedCountries.add(country);
                    const button = document.querySelector('[data-country="' + country + '"]');
                    if (button) {
                        button.classList.add('active');
                    }
                });
                syncCountryCount();
            }

            function clearCountrySelection(skipSync) {
                selectedCountries.clear();
                document.querySelectorAll('.country-pill.active').forEach((el) => el.classList.remove('active'));
                if (!skipSync) {
                    syncCountryCount();
                }
            }

            function pickRandom(arr) {
                return arr[Math.floor(Math.random() * arr.length)];
            }

            function sanitizeQuantity() {
                const input = document.getElementById('quantity');
                let value = parseInt(input.value, 10);
                if (isNaN(value)) {
                    value = 20;
                }
                if (value < 1) {
                    value = 1;
                }
                if (value > 100) {
                    value = 100;
                }
                input.value = value;
                return value;
            }

            function getSelectedValue(name, fallback) {
                const selected = document.querySelector('input[name="' + name + '"]:checked');
                return selected ? selected.value : fallback;
            }

            function getSelectedExtras() {
                const extras = [];
                document.querySelectorAll('.extra-checkbox:checked').forEach((box) => extras.push(box.value));
                return extras;
            }

            function poolByGender(countryData, gender, includeUnisex, style) {
                let pool = [];

                if (gender === 'male') {
                    pool = pool.concat(countryData.male.map((i) => ({
                        name: i.name,
                        style: i.style,
                        popularity: i.popularity,
                        sex: 'male'
                    })));
                } else if (gender === 'female') {
                    pool = pool.concat(countryData.female.map((i) => ({
                        name: i.name,
                        style: i.style,
                        popularity: i.popularity,
                        sex: 'female'
                    })));
                } else {
                    pool = pool
                        .concat(countryData.male.map((i) => ({ name: i.name, style: i.style, popularity: i.popularity, sex: 'male' })))
                        .concat(countryData.female.map((i) => ({ name: i.name, style: i.style, popularity: i.popularity, sex: 'female' })));
                }

                if (includeUnisex) {
                    pool = pool.concat(countryData.unisex.map((i) => ({
                        name: i.name,
                        style: i.style,
                        popularity: i.popularity,
                        sex: 'unisex'
                    })));
                }

                if (style !== 'mixed') {
                    pool = pool.filter((item) => item.style === style);
                }

                if (!pool.length) {
                    pool = countryData.male
                        .concat(countryData.female)
                        .concat(includeUnisex ? countryData.unisex : [])
                        .map((i) => ({ name: i.name, style: i.style, popularity: i.popularity, sex: 'unisex' }));
                }

                return pool;
            }

            function surnameCountByStructure(structure) {
                if (structure === 'firstOnly') {
                    return 0;
                }
                if (structure === 'firstTwo') {
                    return 2;
                }
                if (structure === 'firstFour') {
                    return 4;
                }
                return 1;
            }

            function pickSurnames(surnames, count) {
                if (count === 0) {
                    return [];
                }
                const local = [];
                let attempts = 0;
                while (local.length < count && attempts < 40) {
                    attempts++;
                    const s = pickRandom(surnames);
                    if (!local.includes(s)) {
                        local.push(s);
                    }
                }
                while (local.length < count) {
                    local.push(pickRandom(surnames));
                }
                return local;
            }

            function distribute(total, countries) {
                const base = Math.floor(total / countries.length);
                const rem = total % countries.length;
                const map = {};
                countries.forEach((country, index) => {
                    map[country] = base + (index < rem ? 1 : 0);
                });
                return map;
            }

            function buildRecord(country, config) {
                const data = COUNTRY_BANK[country];
                const firstPool = poolByGender(data, config.gender, config.includeUnisex, config.style);
                const first = pickRandom(firstPool);
                const surnameCount = surnameCountByStructure(config.structure);
                const surnames = pickSurnames(data.surnames, surnameCount);

                const fullName = [first.name].concat(surnames).join(' ');

                const record = {
                    fullName: fullName,
                    firstName: first.name,
                    surnames: surnames,
                    country: country,
                    style: first.style,
                    sex: first.sex,
                    popularity: first.popularity
                };

                if (config.extras.includes('age')) {
                    record.age = Math.floor(Math.random() * 63) + 18;
                }
                if (config.extras.includes('sex')) {
                    record.outputSex = first.sex;
                }
                if (config.extras.includes('nationality')) {
                    record.nationality = data.nationality;
                }
                if (config.extras.includes('locality')) {
                    record.locality = pickRandom(data.localities);
                }
                if (config.extras.includes('language')) {
                    record.language = data.languages[0];
                }
                if (config.extras.includes('popularity')) {
                    record.outputPopularity = first.popularity;
                }

                return record;
            }

            function buildRecordViewText(record, extras) {
                const mainText = extras.includes('country')
                    ? record.fullName + ' (' + record.country + ')'
                    : record.fullName;
                const parts = [mainText];

                if (extras.includes('sex')) {
                    parts.push('sex: ' + record.outputSex);
                }
                if (extras.includes('age')) {
                    parts.push('age: ' + record.age);
                }
                if (extras.includes('nationality')) {
                    parts.push('nationality: ' + record.nationality);
                }
                if (extras.includes('locality')) {
                    parts.push('locality: ' + record.locality);
                }
                if (extras.includes('language')) {
                    parts.push('language: ' + record.language);
                }
                if (extras.includes('popularity')) {
                    parts.push('popularity: ' + record.outputPopularity);
                }

                return parts.join(' | ');
            }

            function buildMainDisplayText(record, extras) {
                return extras.includes('country')
                    ? record.fullName + ' (' + record.country + ')'
                    : record.fullName;
            }

            function buildExtrasOnlyText(record, extras) {
                const parts = [];

                if (extras.includes('sex')) {
                    parts.push('sex: ' + record.outputSex);
                }
                if (extras.includes('age')) {
                    parts.push('age: ' + record.age);
                }
                if (extras.includes('nationality')) {
                    parts.push('nationality: ' + record.nationality);
                }
                if (extras.includes('locality')) {
                    parts.push('locality: ' + record.locality);
                }
                if (extras.includes('language')) {
                    parts.push('language: ' + record.language);
                }
                if (extras.includes('popularity')) {
                    parts.push('popularity: ' + record.outputPopularity);
                }

                return parts.join(' | ');
            }

            function generateNames() {
                const quantity = sanitizeQuantity();
                const countries = Array.from(selectedCountries);
                const style = getSelectedValue('nameStyle', 'mixed');
                const structure = getSelectedValue('nameStructure', 'firstOne');
                const gender = getSelectedValue('gender', 'both');
                const includeUnisex = document.getElementById('includeUnisex').checked;
                const extras = getSelectedExtras();

                const validation = document.getElementById('validationMessage');
                if (!countries.length) {
                    validation.classList.remove('none');
                    validation.textContent = 'Please select at least one country.';
                    return;
                }

                const distribution = distribute(quantity, countries);
                const globalUsed = new Set();
                const result = [];
                const stats = {};

                countries.forEach((country) => {
                    const need = distribution[country];
                    stats[country] = 0;
                    const localUsed = new Set();
                    let attempts = 0;
                    const maxAttempts = Math.max(need * 60, 80);

                    while (stats[country] < need && attempts < maxAttempts) {
                        attempts++;
                        const record = buildRecord(country, {
                            style: style,
                            structure: structure,
                            gender: gender,
                            includeUnisex: includeUnisex,
                            extras: extras
                        });

                        if (!localUsed.has(record.fullName) && !globalUsed.has(record.fullName)) {
                            localUsed.add(record.fullName);
                            globalUsed.add(record.fullName);
                            result.push(record);
                            stats[country]++;
                        }
                    }

                    let fallback = 1;
                    while (stats[country] < need) {
                        const record = buildRecord(country, {
                            style: style,
                            structure: structure,
                            gender: gender,
                            includeUnisex: includeUnisex,
                            extras: extras
                        });

                        const forced = record.fullName + ' ' + fallback;
                        fallback++;
                        if (!localUsed.has(forced) && !globalUsed.has(forced)) {
                            record.fullName = forced;
                            localUsed.add(forced);
                            globalUsed.add(forced);
                            result.push(record);
                            stats[country]++;
                        }
                    }
                });

                generatedRecords = result;
                renderResult(result, stats, { style: style, structure: structure, gender: gender, includeUnisex: includeUnisex, extras: extras });
            }

            function renderResult(records, stats, context) {
                const empty = document.getElementById('emptyState');
                const summaryEl = document.getElementById('summary');
                const statsEl = document.getElementById('stats');
                const cardsEl = document.getElementById('resultsCards');
                const listEl = document.getElementById('resultsList');
                const toolsEl = document.getElementById('resultTools');

                empty.classList.add('none');
                cardsEl.innerHTML = '';
                listEl.innerHTML = '';

                const structTextMap = {
                    firstOnly: 'first name only',
                    firstOne: 'first + 1 surname',
                    firstTwo: 'first + 2 surnames',
                    firstFour: 'first + 4 surnames'
                };

                let summary = records.length + ' realistic names were generated using ' + structTextMap[context.structure] + ' structure';
                summary += ', style ' + context.style + ', gender ' + context.gender;
                if (context.includeUnisex) {
                    summary += ', with ambiguous names enabled';
                }
                summary += '.';

                summaryEl.classList.remove('none');
                summaryEl.textContent = summary;

                const statsLines = [];
                Object.keys(stats).forEach((country) => {
                    statsLines.push(country + ': ' + stats[country] + ' names');
                });
                statsEl.classList.remove('none');
                statsEl.innerHTML = '<strong>Breakdown:</strong><br>' + statsLines.join('<br>');

                if (records.length <= 20) {
                    listEl.classList.add('none');
                    records.forEach((record) => {
                        const mainText = buildMainDisplayText(record, context.extras);
                        const extrasText = buildExtrasOnlyText(record, context.extras);
                        const card = document.createElement('div');
                        card.className = 'name-card';
                        card.innerHTML = '<div class="main">' + mainText + '</div>';
                        if (extrasText !== '') {
                            card.innerHTML += '<div class="meta">' + extrasText + '</div>';
                        }
                        cardsEl.appendChild(card);
                    });
                } else {
                    listEl.classList.remove('none');
                    records.forEach((record) => {
                        const li = document.createElement('li');
                        li.textContent = buildRecordViewText(record, context.extras);
                        listEl.appendChild(li);
                    });
                }

                const plainLines = [summary, '', 'Breakdown:'].concat(statsLines).concat(['']);
                records.forEach((record, index) => {
                    plainLines.push((index + 1) + '. ' + buildRecordViewText(record, context.extras));
                });
                document.getElementById('plainOutput').textContent = plainLines.join('\n');

                toolsEl.classList.remove('none');
            }

            function clearResults() {
                generatedRecords = [];
                document.getElementById('summary').classList.add('none');
                document.getElementById('summary').textContent = '';
                document.getElementById('stats').classList.add('none');
                document.getElementById('stats').innerHTML = '';
                document.getElementById('resultsCards').innerHTML = '';
                document.getElementById('resultsList').innerHTML = '';
                document.getElementById('resultsList').classList.add('none');
                document.getElementById('plainOutput').textContent = '';
                document.getElementById('resultTools').classList.add('none');
                document.getElementById('emptyState').classList.remove('none');
            }

            function selectedExportFields() {
                const extras = getSelectedExtras();
                const base = ['fullName', 'style'];
                if (extras.includes('country')) {
                    base.push('country');
                }
                if (extras.includes('sex')) {
                    base.push('outputSex');
                }
                if (extras.includes('age')) {
                    base.push('age');
                }
                if (extras.includes('nationality')) {
                    base.push('nationality');
                }
                if (extras.includes('locality')) {
                    base.push('locality');
                }
                if (extras.includes('language')) {
                    base.push('language');
                }
                if (extras.includes('popularity')) {
                    base.push('outputPopularity');
                }
                return base;
            }

            function downloadText(filename, text, mimeType) {
                const blob = new Blob([text], { type: mimeType });
                const url = URL.createObjectURL(blob);
                const a = document.createElement('a');
                a.href = url;
                a.download = filename;
                document.body.appendChild(a);
                a.click();
                a.remove();
                URL.revokeObjectURL(url);
            }

            function downloadTxt() {
                if (!generatedRecords.length) {
                    return;
                }
                downloadText('random-names.txt', document.getElementById('plainOutput').textContent, 'text/plain;charset=utf-8');
            }

            function downloadJson() {
                if (!generatedRecords.length) {
                    return;
                }
                const fields = selectedExportFields();
                const output = generatedRecords.map((record) => {
                    const obj = {};
                    fields.forEach((field) => {
                        obj[field] = record[field] !== undefined ? record[field] : '';
                    });
                    return obj;
                });
                downloadText('random-names.json', JSON.stringify(output, null, 2), 'application/json;charset=utf-8');
            }

            function csvEscape(value) {
                const s = String(value === undefined ? '' : value);
                if (s.includes('"') || s.includes(',') || s.includes('\n')) {
                    return '"' + s.replace(/"/g, '""') + '"';
                }
                return s;
            }

            function downloadCsv() {
                if (!generatedRecords.length) {
                    return;
                }
                const fields = selectedExportFields();
                const rows = [fields.join(',')];
                generatedRecords.forEach((record) => {
                    rows.push(fields.map((f) => csvEscape(record[f])).join(','));
                });
                downloadText('random-names.csv', rows.join('\n'), 'text/csv;charset=utf-8');
            }

            function downloadHtmlList(type) {
                if (!generatedRecords.length) {
                    return;
                }
                const extras = getSelectedExtras();
                const tag = type === 'ol' ? 'ol' : 'ul';
                const lines = [];
                lines.push('<!DOCTYPE html>');
                lines.push('<html lang="en">');
                lines.push('<head><meta charset="UTF-8"><meta name="viewport" content="width=device-width, initial-scale=1.0"><title>Random Names List</title></head>');
                lines.push('<body>');
                lines.push('<h1>Random Names Export</h1>');
                lines.push('<' + tag + '>');
                generatedRecords.forEach((record) => {
                    lines.push('<li>' + buildRecordViewText(record, extras).replace(/</g, '&lt;').replace(/>/g, '&gt;') + '</li>');
                });
                lines.push('</' + tag + '>');
                lines.push('</body>');
                lines.push('</html>');

                const filename = type === 'ol' ? 'random-names-ordered-list.html' : 'random-names-unordered-list.html';
                downloadText(filename, lines.join('\n'), 'text/html;charset=utf-8');
            }

            function init() {
                createCountryPills();
                syncCountryCount();
                applyPreset('western');
                sanitizeQuantity();
            }

            init();
        </script></p>
<p>The post <a href="https://imediacto.com/tools/name-generators/random-name-generator/">Random Name Generator</a> appeared first on <a href="https://imediacto.com">Free Online Tools - Imediacto</a>.</p>
]]></content:encoded>
					
					<wfw:commentRss>https://imediacto.com/tools/name-generators/random-name-generator/feed/</wfw:commentRss>
			<slash:comments>0</slash:comments>
		
		
			</item>
		<item>
		<title>Dragon Name Generator</title>
		<link>https://imediacto.com/tools/name-generators/dragon-name-generator/</link>
					<comments>https://imediacto.com/tools/name-generators/dragon-name-generator/#respond</comments>
		
		<dc:creator><![CDATA[Dante]]></dc:creator>
		<pubDate>Tue, 09 Jun 2026 09:30:58 +0000</pubDate>
				<category><![CDATA[Name Generators]]></category>
		<guid isPermaLink="false">https://imediacto.com/?p=407</guid>

					<description><![CDATA[<p>Dragon Name Generator is a free online tool to create dragon names by origin. Generate simple, epic, or mixed dragon names for RPG campaigns, novels, and fantasy worlds.</p>
<p>The post <a href="https://imediacto.com/tools/name-generators/dragon-name-generator/">Dragon Name Generator</a> appeared first on <a href="https://imediacto.com">Free Online Tools - Imediacto</a>.</p>
]]></description>
										<content:encoded><![CDATA[<p><div class="boot dragon-name-generator">
            <div class="row mb-3">
                <div class="col-sm-12">
                    <h2>Generate Dragon Names by Origin</h2>
                    <p>
                        <strong>Dragon Name Generator</strong> is a free online tool focused only on
                        <strong>dragon names</strong>. Choose one or multiple origins such as
                        <strong>Greek, Japanese, Welsh, German, English, Celtic, Nordic, and Latin</strong>, then
                        generate simple, epic, or mixed names for RPG campaigns, fantasy novels, and worldbuilding.
                    </p>
                </div>
            </div>

            <div class="tool-panel">
                <h3 class="mb-1">1) Select origin(s)</h3>
                <p class="help-text">You can mix origins to generate broader dragon naming styles.</p>
                <div id="originsGrid" class="origins-grid"></div>
                <div id="selectedCount" class="counter">0 origins selected</div>

                <div class="inline-controls">
                    <div>
                        <h3 class="mb-1">2) Names per origin</h3>
                        <label for="namesPerOrigin">Choose a value between 1 and 100</label>
                        <input type="number" id="namesPerOrigin" min="1" max="100" value="10">
                        <p class="help-text">If you select 3 origins and choose 10, this tool generates 30 names.</p>
                    </div>

                    <div>
                        <h3 class="mb-1">3) Name complexity</h3>
                        <div class="radio-group">
                            <label for="complexitySimple"><input type="radio" id="complexitySimple" name="complexity" value="simple">Simple</label>
                            <label for="complexityEpic"><input type="radio" id="complexityEpic" name="complexity" value="epic">Epic</label>
                            <label for="complexityMixed"><input type="radio" id="complexityMixed" name="complexity" value="mixed" checked>Mixed</label>
                        </div>
                        <p class="help-text">Simple names are short (Nox, Krios). Epic names are longer and mythic.</p>
                    </div>
                </div>

                <div class="inline-controls">
                    <div>
                        <h3 class="mb-1">4) Gender style</h3>
                        <div class="radio-group">
                            <label for="genderMale"><input type="radio" id="genderMale" name="gender" value="male">Male</label>
                            <label for="genderFemale"><input type="radio" id="genderFemale" name="gender" value="female">Female</label>
                            <label for="genderBoth"><input type="radio" id="genderBoth" name="gender" value="both" checked>Both</label>
                        </div>
                    </div>

                    <div>
                        <h3 class="mb-1">5) Extra options</h3>
                        <div class="radio-group">
                            <label for="withEpithets"><input type="checkbox" id="withEpithets" checked>Include epithets</label>
                        </div>
                        <p class="help-text">Epithets add flavor like "the Ember Tyrant" or "of the Ancient Sky".</p>
                    </div>
                </div>

                <div class="actions">
                    <button class="btn btn-success" onclick="generateNames()"><i class="fa fa-magic"></i> Generate dragon names</button>
                    <button class="btn btn-light" onclick="clearResults()"><i class="fa fa-eraser"></i> Clear results</button>
                </div>

                <div id="summary" class="summary none"></div>
                <div id="stats" class="stats none"></div>

                <div id="resultTools" class="result-tools none">
                    <button class="soft" onclick="copyToClipboard('plainOutput', 'checkCopy')" title="Copy generated names">
                        <i class="fa fa-copy"></i> Copy output
                    </button>
                    <button class="soft" onclick="downloadOutput()" title="Download generated names as TXT">
                        <i class="fa fa-download"></i> Download TXT
                    </button>
                    <div id="checkCopy" class="check none"></div>
                </div>

                <div id="resultsCards" class="results-cards"></div>
                <ol id="resultsList" class="results-list none"></ol>
                <div id="plainOutput" class="none"></div>
            </div>

            <hr>

            <div class="more-notes entry-content">
                <h2>What is a Dragon Name Generator?</h2>
                <p>
                    A <strong>dragon name generator</strong> helps writers, players, and creators build original names
                    for drakes, wyverns, and ancient dragons in fantasy worlds. This online generator focuses on
                    dragon-only naming logic to deliver stronger thematic consistency.
                </p>

                <h2>Why origin-based dragon names matter</h2>
                <p>
                    Different cultures produce different sound patterns. Greek-inspired names often feel mythic and
                    grand, Japanese-inspired names may sound elegant and sharp, and Welsh or Celtic-inspired names can
                    feel ancient and mystical. Origin filters help shape the exact atmosphere you need.
                </p>

                <h2>Simple vs epic dragon names</h2>
                <p>
                    Use <strong>simple dragon names</strong> for fast identification and memorable enemies or mounts,
                    such as <strong>Nox</strong>, <strong>Krios</strong>, <strong>Zyphon</strong>, and
                    <strong>Arax</strong>. Use <strong>epic dragon names</strong> for bosses, lore guardians, and
                    legendary creatures, such as <strong>Vaergahl the Ember Tyrant</strong>.
                </p>

                <h2>Dragon name ideas by origin</h2>
                <h3>Greek dragon names</h3>
                <p>Often mythic, dramatic, and ancient-sounding, great for god-tier dragons and primordial beings.</p>
                <h3>Japanese dragon names</h3>
                <p>Elegant, sharp, and symbolic, useful for sky dragons, temple guardians, and mystical clans.</p>
                <h3>Welsh and Celtic dragon names</h3>
                <p>Mystical and old-world in tone, ideal for ancient bloodlines, runic lore, and sacred mountains.</p>
                <h3>Germanic and Nordic dragon names</h3>
                <p>Strong and heavy phonetics, suitable for war dragons, frost dragons, and iron-scale tyrants.</p>

                <h2>Frequently Asked Questions (FAQ)</h2>
                <h3>Can I use these dragon names in my game or book?</h3>
                <p>Yes. The generated names are provided as creative suggestions for fiction, campaigns, and prototypes.</p>

                <h3>Can I combine origins to create hybrid dragon names?</h3>
                <p>Yes. Select multiple origins and the tool generates names for each selected origin in one run.</p>

                <h3>Why do I see both short and long names in mixed mode?</h3>
                <p>Mixed mode combines simple and epic pipelines to provide a balanced list for common and legendary dragons.</p>
            </div>

            <div class="notes">
                <div class="image"></div>
                <div class="message">
                    <p>
                        Send me your feedback about this <strong>Dragon Name Generator</strong> and tell me if you need
                        more origins, naming rules, or special dragon classes, so I can improve this online tool.
                    </p>
                    <p>
                        You can learn how this generator works or contribute with improvements and bug fixes on Github:
                        <a href="https://github.com/dantovsky/Imediacto-Online-Tool-Set/tree/master/tools/012-dragon-name-generator" target="_blank">Github >> Dragon Name Generator</a>.
                        Pull requests are welcome.
                    </p>
                </div>
            </div>
        </div>

        <script>
            const ORIGIN_NAMES = [
                'Greek', 'Japanese', 'Welsh', 'German', 'American / English', 'Celtic', 'Nordic / Scandinavian', 'Latin / Romance'
            ];

            const selectedOrigins = new Set();
            let generatedItems = [];

            // Curated short names inspired by the requested style.
            const SIMPLE_DRAGON_NAMES = [
                'Nox', 'Krios', 'Zyphon', 'Eireisone', 'Varos', 'Arax', 'Balon', 'Nhil', 'Bazyn', 'Draak',
                'Telarion', 'Virgil', 'Baloryx', 'Ryoko', 'Krin', 'Illuzan', 'Gyo', 'Dreq', 'Temedius', 'Circe',
                'Thrarion', 'Kolloth', 'Heren', 'Drayke', 'Drazyn', 'Vaergahl', 'Skariax', 'Raek', 'Nedryz',
                'Ktakl', 'Felscathor', 'Drakoth', 'Erebus', 'Khmaz', 'Oedyz', 'Hiryur', 'Ahnok', 'Vespak'
            ];

            const ORIGIN_BANK = {
                'Greek': {
                    simplePrefixes: ['dra', 'kri', 'nox', 'zy', 'phe', 'the', 'myr', 'var', 'ara'],
                    simpleSuffixes: ['os', 'on', 'ios', 'ax', 'es', 'or', 'eus', 'ion'],
                    male: ['drak', 'pyr', 'krath', 'nyx', 'aer', 'thal', 'vyr', 'mor'],
                    female: ['dria', 'pyria', 'nyra', 'aeria', 'thalya', 'moria', 'vyria', 'kyria'],
                    neutral: ['ion', 'eon', 'ae', 'or', 'yx', 'eth', 'os', 'yr'],
                    epithets: ['of Olympus', 'the Draconic', 'the Star-Forged', 'the Ember Tyrant', 'of Eternal Sky']
                },
                'Japanese': {
                    simplePrefixes: ['ryu', 'tatsu', 'kyo', 'hiro', 'aki', 'ren', 'kira', 'sora', 'ra'],
                    simpleSuffixes: ['ko', 'shi', 'maru', 'jin', 'ra', 'to', 'ki', 'ya'],
                    male: ['ryu', 'tatsu', 'kamin', 'shiro', 'kuro', 'akio', 'ren', 'haku'],
                    female: ['ryuna', 'tsuki', 'sakura', 'hina', 'kaori', 'aika', 'akira', 'yume'],
                    neutral: ['no', 'ka', 'ri', 'zen', 'maru', 'to', 'mi', 'ra'],
                    epithets: ['of Rising Sun', 'the Celestial Fang', 'of Scarlet Storm', 'the Cloud Serpent', 'the Sky Warden']
                },
                'Welsh': {
                    simplePrefixes: ['draig', 'gwyn', 'eir', 'taran', 'mor', 'cae', 'bryn', 'dun'],
                    simpleSuffixes: ['yn', 'or', 'eth', 'oc', 'wen', 'an', 'ach', 'ion'],
                    male: ['draig', 'gwyn', 'coch', 'taran', 'mawr', 'bryn', 'rhys', 'mor'],
                    female: ['draiga', 'gwena', 'eira', 'cerys', 'anwen', 'ffion', 'mora', 'rhi'],
                    neutral: ['dd', 'yn', 'or', 'eth', 'ach', 'wen', 'ion', 'air'],
                    epithets: ['of the Mountain Crown', 'the Ancient Scale', 'of the Red Peak', 'the Hollow Flame', 'of the Deep Vale']
                },
                'German': {
                    simplePrefixes: ['dra', 'feu', 'stur', 'nacht', 'eis', 'blit', 'krag', 'val'],
                    simpleSuffixes: ['gar', 'hart', 'wolf', 'en', 'ach', 'or', 'ing', 'ald'],
                    male: ['wurm', 'feuer', 'sturm', 'nacht', 'blitz', 'stein', 'krag', 'eisen'],
                    female: ['wurma', 'feura', 'sturma', 'nachtsa', 'blitza', 'steina', 'eisa', 'vala'],
                    neutral: ['fang', 'kraft', 'licht', 'wald', 'heim', 'horn', 'drang', 'zorn'],
                    epithets: ['the Iron Maw', 'of Black Mountain', 'the Thunder Scale', 'the Rift Keeper', 'of Ember Forge']
                },
                'American / English': {
                    simplePrefixes: ['dra', 'sky', 'ash', 'storm', 'night', 'ember', 'vex', 'raz'],
                    simpleSuffixes: ['on', 'er', 'ex', 'yn', 'or', 'us', 'ix', 'an'],
                    male: ['drake', 'storm', 'ash', 'shadow', 'iron', 'blaze', 'flint', 'crag'],
                    female: ['draya', 'storma', 'embera', 'ashara', 'lyra', 'nova', 'skya', 'fira'],
                    neutral: ['fang', 'wing', 'fire', 'bane', 'scale', 'claw', 'thorn', 'mist'],
                    epithets: ['the Dread Flame', 'of Ancient Skies', 'the Rift Hunter', 'the Ash Crown', 'of the Storm Coast']
                },
                'Celtic': {
                    simplePrefixes: ['bal', 'mor', 'finn', 'sid', 'cael', 'ru', 'ail', 'dra'],
                    simpleSuffixes: ['or', 'eth', 'an', 'wyn', 'ach', 'on', 'ys', 'air'],
                    male: ['balor', 'morr', 'cael', 'fionn', 'ruad', 'draoi', 'aed', 'sionn'],
                    female: ['balora', 'morra', 'caela', 'fiona', 'ruana', 'aine', 'siona', 'briana'],
                    neutral: ['sidhe', 'wyn', 'eth', 'an', 'or', 'air', 'stone', 'vale'],
                    epithets: ['of the Old Grove', 'the Rune-Bound', 'of Moonlit Hills', 'the Wild Ember', 'of Forgotten Circles']
                },
                'Nordic / Scandinavian': {
                    simplePrefixes: ['drau', 'skol', 'fro', 'ulv', 'val', 'thor', 'grim', 'yr'],
                    simpleSuffixes: ['nir', 'son', 'var', 'rik', 'gard', 'heim', 'thor', 'ulf'],
                    male: ['drak', 'frost', 'ulv', 'thorn', 'grim', 'valk', 'bjorn', 'skog'],
                    female: ['draka', 'frosta', 'ulva', 'vala', 'sigrid', 'freya', 'yrsa', 'astrid'],
                    neutral: ['nir', 'heim', 'gard', 'skarn', 'volt', 'rek', 'fang', 'hraf'],
                    epithets: ['of Frozen Spine', 'the Winter Tyrant', 'of Nine Storms', 'the Rune Maw', 'of the Iron Fjord']
                },
                'Latin / Romance': {
                    simplePrefixes: ['draco', 'igni', 'nox', 'sol', 'aure', 'voro', 'ser', 'lux'],
                    simpleSuffixes: ['us', 'is', 'or', 'a', 'ex', 'ius', 'um', 'on'],
                    male: ['draco', 'ignis', 'nox', 'sol', 'ferox', 'aureus', 'vorax', 'umbra'],
                    female: ['draca', 'ignia', 'noxia', 'solara', 'aurelia', 'voria', 'umbra', 'luna'],
                    neutral: ['rex', 'axis', 'or', 'is', 'um', 'ar', 'enix', 'vel'],
                    epithets: ['the Infernal', 'of Eternal Flame', 'the Golden Scale', 'of the Dusk Empire', 'the Sky Sovereign']
                }
            };

            function createOriginPills() {
                const grid = document.getElementById('originsGrid');
                grid.innerHTML = '';

                ORIGIN_NAMES.forEach((name) => {
                    const button = document.createElement('button');
                    button.type = 'button';
                    button.className = 'origin-pill';
                    button.textContent = name;
                    button.setAttribute('data-origin', name);

                    button.addEventListener('click', function () {
                        toggleOrigin(name, button);
                    });

                    grid.appendChild(button);
                });
            }

            function toggleOrigin(originName, button) {
                if (selectedOrigins.has(originName)) {
                    selectedOrigins.delete(originName);
                    button.classList.remove('active');
                } else {
                    selectedOrigins.add(originName);
                    button.classList.add('active');
                }
                updateSelectedCount();
            }

            function updateSelectedCount() {
                const count = selectedOrigins.size;
                document.getElementById('selectedCount').textContent = count + (count === 1 ? ' origin selected' : ' origins selected');
            }

            function sanitizeCount(value) {
                let count = parseInt(value, 10);
                if (isNaN(count)) {
                    count = 10;
                }
                if (count < 1) {
                    count = 1;
                }
                if (count > 100) {
                    count = 100;
                }
                return count;
            }

            function pickRandom(arr) {
                return arr[Math.floor(Math.random() * arr.length)];
            }

            function capitalizeWords(text) {
                return text
                    .split(' ')
                    .map((word) => word.charAt(0).toUpperCase() + word.slice(1))
                    .join(' ');
            }

            function getGenderValue() {
                const selected = document.querySelector('input[name="gender"]:checked');
                return selected ? selected.value : 'both';
            }

            function getComplexityValue() {
                const selected = document.querySelector('input[name="complexity"]:checked');
                return selected ? selected.value : 'mixed';
            }

            function buildCorePool(origin, gender) {
                const data = ORIGIN_BANK[origin];
                if (gender === 'male') {
                    return data.male.concat(data.neutral);
                }
                if (gender === 'female') {
                    return data.female.concat(data.neutral);
                }
                return data.male.concat(data.female).concat(data.neutral);
            }

            function buildSimpleName(origin, gender) {
                const data = ORIGIN_BANK[origin];

                if (Math.random() < 0.3) {
                    return pickRandom(SIMPLE_DRAGON_NAMES);
                }

                let prefix = pickRandom(data.simplePrefixes);
                let suffix = pickRandom(data.simpleSuffixes);

                if (gender === 'female' && Math.random() < 0.35 && !suffix.endsWith('a')) {
                    suffix = suffix + 'a';
                }
                if (gender === 'male' && Math.random() < 0.2 && suffix.endsWith('a')) {
                    suffix = suffix.slice(0, -1);
                }

                const name = prefix + suffix;
                return capitalizeWords(name);
            }

            function buildEpicName(origin, gender, includeEpithets) {
                const pool = buildCorePool(origin, gender);
                const chunks = Math.random() < 0.5 ? 3 : 4;
                let name = '';

                for (let i = 0; i < chunks; i++) {
                    name += pickRandom(pool);
                }

                name = capitalizeWords(name);

                if (Math.random() < 0.2) {
                    name = name + '-' + capitalizeWords(pickRandom(pool));
                }

                if (includeEpithets && Math.random() < 0.55) {
                    name += ' ' + pickRandom(ORIGIN_BANK[origin].epithets);
                }

                return name;
            }

            function generateDragonName(origin, gender, complexity, includeEpithets) {
                if (complexity === 'simple') {
                    return { name: buildSimpleName(origin, gender), type: 'Simple' };
                }

                if (complexity === 'epic') {
                    return { name: buildEpicName(origin, gender, includeEpithets), type: 'Epic' };
                }

                if (Math.random() < 0.5) {
                    return { name: buildSimpleName(origin, gender), type: 'Simple' };
                }

                return { name: buildEpicName(origin, gender, includeEpithets), type: 'Epic' };
            }

            // Anti-repetition: unique names in the same generation with retries + deterministic fallback.
            function generateUniqueByOrigin(origin, gender, complexity, amount, includeEpithets, usedGlobal) {
                const localUsed = new Set();
                const items = [];
                const maxAttempts = amount * 35;
                let attempts = 0;

                while (items.length < amount && attempts < maxAttempts) {
                    attempts++;
                    const candidate = generateDragonName(origin, gender, complexity, includeEpithets);
                    if (!localUsed.has(candidate.name) && !usedGlobal.has(candidate.name)) {
                        localUsed.add(candidate.name);
                        usedGlobal.add(candidate.name);
                        items.push({ origin: origin, name: candidate.name, type: candidate.type });
                    }
                }

                let fallback = 1;
                while (items.length < amount) {
                    const candidate = generateDragonName(origin, gender, complexity, includeEpithets);
                    const forced = candidate.name + ' ' + fallback;
                    fallback++;
                    if (!localUsed.has(forced) && !usedGlobal.has(forced)) {
                        localUsed.add(forced);
                        usedGlobal.add(forced);
                        items.push({ origin: origin, name: forced, type: candidate.type });
                    }
                }

                return items;
            }

            function buildSummary(total, origins, complexity) {
                const modeText = complexity === 'mixed' ? 'mixed' : complexity;
                if (origins.length === 1) {
                    return total + ' ' + modeText + ' dragon names were generated for ' + origins[0] + ' origin.';
                }

                if (origins.length === 2) {
                    return total + ' ' + modeText + ' dragon names were generated for ' + origins[0] + ' and ' + origins[1] + ' origins.';
                }

                const last = origins[origins.length - 1];
                const firstPart = origins.slice(0, -1).join(', ');
                return total + ' ' + modeText + ' dragon names were generated for ' + firstPart + ' and ' + last + ' origins.';
            }

            function buildStats(statsMap) {
                const lines = ['<strong>Breakdown:</strong>'];
                Object.keys(statsMap).forEach((origin) => {
                    const s = statsMap[origin];
                    lines.push(origin + ': ' + s.total + ' names (' + s.simple + ' simple, ' + s.epic + ' epic)');
                });
                return lines.join('<br>');
            }

            function renderResults(items) {
                const cardsEl = document.getElementById('resultsCards');
                const listEl = document.getElementById('resultsList');

                cardsEl.innerHTML = '';
                listEl.innerHTML = '';

                if (items.length <= 20) {
                    listEl.classList.add('none');
                    items.forEach((item) => {
                        const card = document.createElement('div');
                        card.className = 'name-card';
                        card.innerHTML = '<span class="meta">' + item.origin + ' / ' + item.type + '</span>' + item.name;
                        cardsEl.appendChild(card);
                    });
                } else {
                    listEl.classList.remove('none');
                    items.forEach((item) => {
                        const li = document.createElement('li');
                        li.textContent = item.name + ' (' + item.origin + ' / ' + item.type + ')';
                        listEl.appendChild(li);
                    });
                }
            }

            function buildPlainOutput(items, summaryText, statsHtml) {
                const statsPlain = statsHtml.replace(/<strong>|<\/strong>/g, '').replace(/<br>/g, '\n');
                const lines = [summaryText, '', statsPlain, ''];
                items.forEach((item, index) => {
                    lines.push((index + 1) + '. ' + item.name + ' [' + item.origin + ' / ' + item.type + ']');
                });
                return lines.join('\n');
            }

            function generateNames() {
                const quantityInput = document.getElementById('namesPerOrigin');
                const amount = sanitizeCount(quantityInput.value);
                quantityInput.value = amount;

                const origins = Array.from(selectedOrigins);
                const complexity = getComplexityValue();
                const gender = getGenderValue();
                const includeEpithets = document.getElementById('withEpithets').checked;

                const summaryEl = document.getElementById('summary');
                const statsEl = document.getElementById('stats');
                const resultTools = document.getElementById('resultTools');

                if (origins.length === 0) {
                    summaryEl.classList.remove('none');
                    summaryEl.textContent = 'Select at least one origin before generating dragon names.';
                    statsEl.classList.add('none');
                    statsEl.innerHTML = '';
                    resultTools.classList.add('none');
                    document.getElementById('resultsCards').innerHTML = '';
                    document.getElementById('resultsList').innerHTML = '';
                    document.getElementById('resultsList').classList.add('none');
                    document.getElementById('plainOutput').textContent = '';
                    generatedItems = [];
                    return;
                }

                const usedGlobal = new Set();
                const results = [];
                const statsMap = {};

                origins.forEach((origin) => {
                    const chunk = generateUniqueByOrigin(origin, gender, complexity, amount, includeEpithets, usedGlobal);
                    statsMap[origin] = { total: chunk.length, simple: 0, epic: 0 };

                    chunk.forEach((item) => {
                        if (item.type === 'Simple') {
                            statsMap[origin].simple++;
                        } else {
                            statsMap[origin].epic++;
                        }
                        results.push(item);
                    });
                });

                generatedItems = results;
                const summaryText = buildSummary(results.length, origins, complexity);
                const statsHtml = buildStats(statsMap);

                summaryEl.classList.remove('none');
                summaryEl.textContent = summaryText;
                statsEl.classList.remove('none');
                statsEl.innerHTML = statsHtml;

                renderResults(results);

                document.getElementById('plainOutput').textContent = buildPlainOutput(results, summaryText, statsHtml);
                resultTools.classList.remove('none');
            }

            function downloadOutput() {
                if (!generatedItems.length) {
                    return;
                }
                const text = document.getElementById('plainOutput').textContent;
                download('dragon-names.txt', text);
            }

            function clearResults() {
                generatedItems = [];
                document.getElementById('summary').classList.add('none');
                document.getElementById('summary').textContent = '';
                document.getElementById('stats').classList.add('none');
                document.getElementById('stats').innerHTML = '';
                document.getElementById('resultTools').classList.add('none');
                document.getElementById('resultsCards').innerHTML = '';
                document.getElementById('resultsList').innerHTML = '';
                document.getElementById('resultsList').classList.add('none');
                document.getElementById('plainOutput').textContent = '';
            }

            function presetInitialGeneration() {
                const defaultOrigin = 'Greek';
                selectedOrigins.add(defaultOrigin);
                const button = document.querySelector('[data-origin="' + defaultOrigin + '"]');
                if (button) {
                    button.classList.add('active');
                }
                updateSelectedCount();
                generateNames();
            }

            createOriginPills();
            updateSelectedCount();
            presetInitialGeneration();
        </script></p>
<p>The post <a href="https://imediacto.com/tools/name-generators/dragon-name-generator/">Dragon Name Generator</a> appeared first on <a href="https://imediacto.com">Free Online Tools - Imediacto</a>.</p>
]]></content:encoded>
					
					<wfw:commentRss>https://imediacto.com/tools/name-generators/dragon-name-generator/feed/</wfw:commentRss>
			<slash:comments>0</slash:comments>
		
		
			</item>
		<item>
		<title>Fantasy Name Generator</title>
		<link>https://imediacto.com/tools/name-generators/fantasy-name-generator/</link>
					<comments>https://imediacto.com/tools/name-generators/fantasy-name-generator/#respond</comments>
		
		<dc:creator><![CDATA[Dante]]></dc:creator>
		<pubDate>Mon, 01 Jun 2026 01:41:02 +0000</pubDate>
				<category><![CDATA[Name Generators]]></category>
		<category><![CDATA[fantasy name generator]]></category>
		<guid isPermaLink="false">https://imediacto.com/?p=400</guid>

					<description><![CDATA[<p>Fantasy Name Generator is a free online tool to create random fantasy character and world names by category. Generate names for dragons, elves, kingdoms, pirates and more.</p>
<p>The post <a href="https://imediacto.com/tools/name-generators/fantasy-name-generator/">Fantasy Name Generator</a> appeared first on <a href="https://imediacto.com">Free Online Tools - Imediacto</a>.</p>
]]></description>
										<content:encoded><![CDATA[<p><div class="boot fantasy-name-generator">
            <div class="row mb-3">
                <div class="col-sm-12">
                    <h2>Generate Fantasy Names by Category</h2>
                    <p>
                        <strong>Fantasy Name Generator</strong> is a free online tool to create random names for fantasy
                        characters, creatures and places. Choose one or multiple categories such as
                        <strong>Dragons, Elves, Goblins, Kingdoms and Cities</strong>, pick the amount of names, choose
                        the gender and generate your list instantly.
                    </p>
                </div>
            </div>

            <div class="tool-panel">
                <h3 class="mb-1">1) Select one or more categories</h3>
                <p class="help-text">You can combine categories to generate mixed fantasy naming sets.</p>
                <div id="categoriesGrid" class="categories-grid"></div>
                <div id="selectedCount" class="counter">0 categories selected</div>

                <div class="inline-controls">
                    <div>
                        <h3 class="mb-1">2) Names per category</h3>
                        <label for="namesPerCategory">Choose a value between 1 and 100</label>
                        <input type="number" id="namesPerCategory" min="1" max="100" value="10">
                        <p class="help-text">If you select 3 categories and choose 10, the tool will generate 30 names.</p>
                    </div>

                    <div>
                        <h3 class="mb-1">3) Gender</h3>
                        <div class="radio-group">
                            <label for="genderMale"><input type="radio" id="genderMale" name="gender" value="male">Male</label>
                            <label for="genderFemale"><input type="radio" id="genderFemale" name="gender" value="female">Female</label>
                            <label for="genderBoth"><input type="radio" id="genderBoth" name="gender" value="both" checked>Both</label>
                        </div>
                        <p class="help-text">Both uses male and female styles and still avoids duplicate names in the same generation.</p>
                    </div>
                </div>

                <div class="actions">
                    <button class="btn btn-success" onclick="generateNames()"><i class="fa fa-magic"></i> Generate fantasy names</button>
                    <button class="btn btn-light" onclick="clearResults()"><i class="fa fa-eraser"></i> Clear results</button>
                </div>

                <div id="summary" class="summary none"></div>

                <div id="resultTools" class="result-tools none">
                    <button class="soft" onclick="copyToClipboard('plainOutput', 'checkCopy')" title="Copy generated names">
                        <i class="fa fa-copy"></i> Copy output
                    </button>
                    <button class="soft" onclick="downloadOutput()" title="Download generated names as TXT">
                        <i class="fa fa-download"></i> Download TXT
                    </button>
                    <div id="checkCopy" class="check none"></div>
                </div>

                <div id="resultsCards" class="results-cards"></div>
                <ol id="resultsList" class="results-list none"></ol>
                <div id="plainOutput" class="none"></div>
            </div>

            <hr>

            <div class="more-notes entry-content">
                <h2>What is a Fantasy Name Generator?</h2>
                <p>
                    A <strong>fantasy name generator</strong> is a writing and game design tool used to create names for
                    heroes, villains, magical creatures and fictional places. Authors, RPG players and worldbuilders
                    often need many names quickly, and random generation helps keep the creative flow moving.
                </p>
                <p>
                    This tool supports several naming contexts, from <strong>dragon names</strong> and
                    <strong>elf names</strong> to <strong>kingdom names</strong> and <strong>city names</strong>. You can
                    combine categories to build richer worlds for stories, tabletop RPG campaigns and fantasy games.
                </p>

                <h3>Why use category-based fantasy names?</h3>
                <ul>
                    <li><strong>Consistency:</strong> each category uses a distinct naming style.</li>
                    <li><strong>Speed:</strong> generate many names in one click.</li>
                    <li><strong>Flexibility:</strong> use single or multi-category output.</li>
                    <li><strong>Anti-repetition:</strong> the generator avoids duplicate names in the same run.</li>
                </ul>

                <h3>Use Cases</h3>
                <p>
                    Use this free fantasy naming tool to create names for novels, game prototypes, DnD campaigns,
                    character sheets, factions, regions, ports, pirate crews and mythical races.
                </p>

                <h2>The origins behind fantasy names</h2>
                <p>
                    Fantasy names are often inspired by ancient languages, mythological traditions, medieval history,
                    and folklore from different cultures. Many iconic names in fantasy literature combine soft vowels,
                    hard consonants, and symbolic meanings to communicate power, mystery, lineage, or magic.
                </p>
                <p>
                    In high fantasy settings, elves usually receive melodic and elegant names, dwarves use sturdy and
                    clan-oriented naming structures, and orcs tend to have short, impactful, and guttural sounds.
                    Understanding these naming roots helps writers and players create characters that feel more
                    believable inside a fantasy world.
                </p>

                <h2>How does the Fantasy Name Generator work?</h2>
                <p>
                    Simply select your preferred category (such as Elves, Dwarves, Wizards, Orcs, Dragons, or
                    Kingdoms), choose the gender style, define the number of names, and click "Generate fantasy
                    names". The tool combines fantasy-inspired prefixes, syllables, and suffixes to build authentic
                    names for characters, races, and locations.
                </p>
                <p>
                    You can also select multiple categories at once to create mixed name sets for RPG campaigns,
                    fictional civilizations, guilds, or worldbuilding projects. The anti-repetition logic helps reduce
                    duplicate outputs during each generation cycle.
                </p>

                <h2>Fantasy name ideas by race and class</h2>
                <h3>Names for Elves (Elf Names)</h3>
                <p>
                    Elven names are usually melodic, with flowing vowels and elegant rhythm. Examples:
                    <strong>Elandorr</strong>, <strong>Aerith</strong>, <strong>Laerion</strong>,
                    <strong>Myrielle</strong>.
                </p>

                <h3>Names for Dwarves (Dwarf Names)</h3>
                <p>
                    Dwarf names are robust and grounded, often linked to clans, stone, metal, and craftsmanship.
                    Examples: <strong>Thorgar Ironfoot</strong>, <strong>Bramdur</strong>,
                    <strong>Kazgrim Stonebeard</strong>, <strong>Durik Emberhammer</strong>.
                </p>

                <h3>Names for Orcs and Warriors</h3>
                <p>
                    Orc and warrior names favor aggressive phonetics and short, memorable sounds. Examples:
                    <strong>Grommash</strong>, <strong>Garruk</strong>, <strong>Drakzul</strong>,
                    <strong>Krothar</strong>.
                </p>

                <h2>Frequently Asked Questions (FAQ)</h2>

                <h3>Can I use these names in my book or commercial game?</h3>
                <p>
                    Yes. The generated names are free to use as creative suggestions for fiction, RPG characters,
                    campaigns, and game prototypes.
                </p>

                <h3>How do I choose a good name for an RPG character?</h3>
                <p>
                    A strong RPG name should reflect the character's race, role, social background, and personality.
                    Noble characters often benefit from longer and cleaner names, while wild creatures and frontline
                    warriors usually fit short and impactful names.
                </p>

                <h3>Do these generated names fit games like World of Warcraft or D&D?</h3>
                <p>
                    Absolutely. The naming styles are designed for classic fantasy atmospheres, making them suitable
                    for Dungeons & Dragons, Pathfinder, Warcraft-inspired settings, and other tabletop or digital RPG
                    experiences.
                </p>
            </div>

            <div class="notes">
                <div class="image"></div>
                <div class="message">
                    <p>
                        Send me your feedback about this <strong>Fantasy Name Generator</strong> and let me know if you
                        need a specific naming style, then I can improve this online tool with new rules and categories.
                        Also, tell me if you need another <strong>RPG tool</strong>, <strong>writing tool</strong> or
                        <strong>coding tool set</strong>.
                    </p>
                    <p>
                        You can learn how this tool works or contribute with improvements and bug fixes on Github:
                        <a href="https://github.com/dantovsky/Imediacto-Online-Tool-Set/tree/master/tools/011-fantasy-name-generator" target="_blank">Github >> Fantasy Name Generator</a>.
                        Pull requests are welcome.
                    </p>
                </div>
            </div>
        </div>

        <script>
            const CATEGORY_NAMES = [
                'Human', 'Angel', 'Aliens', 'Centaurs', 'Demons', 'Dragons', 'Elves', 'Fairies', 'Giants', 'Gnomes',
                'Goblins', 'Imps', 'Merfolk', 'Ogres', 'Orks', 'Pixies', 'Sea monsters', 'Trolls', 'Unicorns',
                'Vampires', 'Werewolves', 'Witches / Wizards', 'Yeties', 'Zombies', 'Pirate', 'Ship', 'Kingdom',
                'Country', 'City', 'Town'
            ];

            const selectedCategories = new Set();
            let generatedItems = [];

            const SYLLABLE_BANK = {
                Human: {
                    male: ['al', 'ric', 'tor', 'dan', 'mar', 'fen', 'lor', 'vin', 'gar', 'hal'],
                    female: ['ara', 'lia', 'mira', 'sel', 'ena', 'dora', 'yra', 'nora', 'fina', 'lara'],
                    neutral: ['brin', 'cael', 'wyn', 'tal', 'ren', 'sor']
                },
                Angel: {
                    male: ['el', 'zar', 'iel', 'or', 'ram', 'hael', 'thon', 'mal'],
                    female: ['ael', 'riel', 'ana', 'lya', 'sera', 'miel', 'ora', 'ziel'],
                    neutral: ['sol', 'lum', 'eth', 'kir', 'aer', 'vyr']
                },
                Aliens: {
                    male: ['xar', 'zor', 'qen', 'vak', 'thr', 'gon', 'kri', 'ul'],
                    female: ['xia', 'ziri', 'qira', 'vexa', 'thra', 'goni', 'krya', 'ula'],
                    neutral: ['xe', 'qo', 'vr', 'zi', 'ka', 'nu']
                },
                Centaurs: {
                    male: ['bron', 'kar', 'thal', 'dor', 'magn', 'per', 'rhun', 'vorn'],
                    female: ['bria', 'kara', 'thala', 'doria', 'magna', 'pera', 'rhuna', 'vorna'],
                    neutral: ['hoof', 'glen', 'step', 'mane', 'oak', 'ridge']
                },
                Demons: {
                    male: ['az', 'krag', 'mor', 'bal', 'rax', 'dru', 'vor', 'zhul'],
                    female: ['aza', 'kira', 'mora', 'bala', 'raxa', 'dria', 'vora', 'zhula'],
                    neutral: ['ash', 'hex', 'void', 'grim', 'bane', 'scar']
                },
                Dragons: {
                    male: ['dra', 'gor', 'thar', 'vyr', 'rax', 'kran', 'zor', 'fyre'],
                    female: ['dria', 'gora', 'thara', 'vyra', 'raxa', 'krana', 'zora', 'fyra'],
                    neutral: ['scale', 'flame', 'claw', 'ember', 'wing', 'smoke']
                },
                Elves: {
                    male: ['ae', 'lin', 'thal', 'eris', 'fae', 'nor', 'sil', 'elor'],
                    female: ['aela', 'lina', 'thalia', 'eris', 'faena', 'noria', 'sila', 'elora'],
                    neutral: ['moon', 'leaf', 'star', 'bloom', 'mist', 'song']
                },
                Fairies: {
                    male: ['pip', 'nib', 'til', 'fae', 'wisp', 'lark', 'flyn', 'spark'],
                    female: ['pippa', 'niba', 'tila', 'faeya', 'wispa', 'larka', 'flyna', 'sparka'],
                    neutral: ['dew', 'petal', 'glow', 'dust', 'flutter', 'twirl']
                },
                Giants: {
                    male: ['grom', 'thok', 'brak', 'ulv', 'morn', 'darg', 'krol', 'varg'],
                    female: ['groma', 'thoka', 'braka', 'ulva', 'morna', 'darga', 'krola', 'varga'],
                    neutral: ['stone', 'peak', 'hammer', 'ridge', 'boulder', 'crag']
                },
                Gnomes: {
                    male: ['nim', 'fizz', 'brim', 'cog', 'tink', 'wob', 'pim', 'gub'],
                    female: ['nima', 'fizza', 'brima', 'coga', 'tinka', 'woba', 'pima', 'guba'],
                    neutral: ['gear', 'spark', 'clock', 'whistle', 'bolt', 'gadget']
                },
                Goblins: {
                    male: ['grib', 'snik', 'krub', 'mog', 'zib', 'rag', 'trog', 'blik'],
                    female: ['griba', 'snika', 'kruba', 'moga', 'ziba', 'raga', 'troga', 'blika'],
                    neutral: ['tooth', 'mud', 'scrap', 'fang', 'sneak', 'grin']
                },
                Imps: {
                    male: ['zip', 'nex', 'vib', 'tik', 'mox', 'drip', 'rix', 'fum'],
                    female: ['zipa', 'nexa', 'viba', 'tika', 'moxa', 'dripa', 'rixa', 'fuma'],
                    neutral: ['spark', 'snicker', 'smudge', 'flick', 'hop', 'blink']
                },
                Merfolk: {
                    male: ['mar', 'thal', 'orin', 'kai', 'nere', 'drel', 'vash', 'lyr'],
                    female: ['mara', 'thalia', 'orina', 'kaia', 'nera', 'drela', 'vasha', 'lyra'],
                    neutral: ['tide', 'reef', 'wave', 'pearl', 'foam', 'shell']
                },
                Ogres: {
                    male: ['ug', 'brut', 'mog', 'kran', 'thud', 'gar', 'snor', 'drum'],
                    female: ['uga', 'bruta', 'moga', 'krana', 'thuda', 'gara', 'snora', 'druma'],
                    neutral: ['swamp', 'club', 'bog', 'stomp', 'mire', 'grub']
                },
                Orks: {
                    male: ['gash', 'krug', 'thrak', 'ug', 'morg', 'brak', 'zug', 'drok'],
                    female: ['gasha', 'kruga', 'thraka', 'uga', 'morga', 'braka', 'zuga', 'droka'],
                    neutral: ['war', 'iron', 'axe', 'rage', 'scar', 'blood']
                },
                Pixies: {
                    male: ['pin', 'twix', 'bree', 'nib', 'lumo', 'spri', 'tiv', 'wim'],
                    female: ['pina', 'twixa', 'bria', 'niba', 'lumia', 'spria', 'tiva', 'wima'],
                    neutral: ['dust', 'petal', 'beam', 'flutter', 'wink', 'dew']
                },
                'Sea monsters': {
                    male: ['krak', 'thol', 'dred', 'marn', 'vash', 'gor', 'hyd', 'nar'],
                    female: ['kraka', 'thola', 'dreda', 'marna', 'vasha', 'gora', 'hydra', 'nara'],
                    neutral: ['depth', 'abyss', 'tide', 'maw', 'storm', 'brine']
                },
                Trolls: {
                    male: ['grum', 'thog', 'bruk', 'snarl', 'krog', 'dunk', 'mug', 'vrak'],
                    female: ['gruma', 'thoga', 'bruka', 'snarla', 'kroga', 'dunka', 'muga', 'vraka'],
                    neutral: ['moss', 'bridge', 'rock', 'cave', 'stump', 'grit']
                },
                Unicorns: {
                    male: ['ael', 'prys', 'lune', 'ser', 'myr', 'faun', 'ior', 'glis'],
                    female: ['aela', 'prysa', 'lunea', 'sera', 'myra', 'fauna', 'iora', 'glisa'],
                    neutral: ['moon', 'glimmer', 'starlight', 'dawn', 'crystal', 'rainbow']
                },
                Vampires: {
                    male: ['vlad', 'drak', 'noct', 'serg', 'mor', 'raz', 'vel', 'nik'],
                    female: ['vlada', 'draka', 'nocta', 'serga', 'mora', 'raza', 'vela', 'nika'],
                    neutral: ['night', 'blood', 'veil', 'shadow', 'thirst', 'crypt']
                },
                Werewolves: {
                    male: ['wulf', 'gar', 'lycan', 'thorn', 'draug', 'fen', 'rake', 'grim'],
                    female: ['wulfa', 'gara', 'lycana', 'thorna', 'drauga', 'fena', 'raka', 'grima'],
                    neutral: ['moon', 'fang', 'howl', 'pelt', 'claw', 'hunt']
                },
                'Witches / Wizards': {
                    male: ['mer', 'alz', 'vor', 'quill', 'zan', 'ther', 'rune', 'cal'],
                    female: ['mera', 'alza', 'vora', 'quilla', 'zana', 'thera', 'runa', 'cala'],
                    neutral: ['spell', 'arcane', 'sigil', 'potion', 'glyph', 'hex']
                },
                Yeties: {
                    male: ['yor', 'thrum', 'glak', 'fros', 'bor', 'krim', 'snor', 'vak'],
                    female: ['yora', 'thruma', 'glaka', 'frosa', 'bora', 'krima', 'snora', 'vaka'],
                    neutral: ['frost', 'ice', 'snow', 'blizzard', 'peak', 'glacier']
                },
                Zombies: {
                    male: ['rot', 'grim', 'mold', 'zed', 'rag', 'nox', 'dec', 'ghoul'],
                    female: ['rota', 'grima', 'molda', 'zeda', 'raga', 'noxa', 'deca', 'ghoula'],
                    neutral: ['grave', 'crypt', 'bone', 'ash', 'dust', 'hunger']
                },
                Pirate: {
                    male: ['rack', 'flint', 'scar', 'brine', 'jack', 'marl', 'drift', 'hook'],
                    female: ['racka', 'flinta', 'scara', 'brina', 'jacka', 'marla', 'drifta', 'hooka'],
                    neutral: ['black', 'tide', 'cutlass', 'reef', 'anchor', 'storm']
                },
                Ship: {
                    male: ['iron', 'storm', 'salt', 'drift', 'black', 'wind', 'wave', 'reef'],
                    female: ['ivory', 'silver', 'scarlet', 'golden', 'misty', 'moon', 'azure', 'brave'],
                    neutral: ['voyager', 'spear', 'banner', 'gale', 'serpent', 'mariner']
                },
                Kingdom: {
                    male: ['val', 'drak', 'eld', 'thor', 'nor', 'grim', 'cald', 'mor'],
                    female: ['vala', 'draka', 'elda', 'thora', 'nora', 'grima', 'calda', 'mora'],
                    neutral: ['realm', 'crown', 'throne', 'dominion', 'keep', 'spire']
                },
                Country: {
                    male: ['ard', 'bel', 'cor', 'dal', 'est', 'fal', 'gor', 'hal'],
                    female: ['arda', 'bela', 'cora', 'dala', 'esta', 'fala', 'gora', 'hala'],
                    neutral: ['lands', 'union', 'province', 'domain', 'expanse', 'nation']
                },
                City: {
                    male: ['ash', 'briar', 'crest', 'dawn', 'ember', 'frost', 'glen', 'harbor'],
                    female: ['astra', 'bria', 'cela', 'doria', 'elya', 'fira', 'gala', 'helia'],
                    neutral: ['port', 'gate', 'hold', 'haven', 'ford', 'market']
                },
                Town: {
                    male: ['oak', 'river', 'hill', 'wind', 'stone', 'mead', 'pine', 'fox'],
                    female: ['willow', 'rose', 'ivy', 'daisy', 'hazel', 'lily', 'violet', 'maple'],
                    neutral: ['crossing', 'village', 'brook', 'field', 'mill', 'hollow']
                }
            };

            const CATEGORY_TITLES = {
                Human: ['the Swift', 'the Wanderer', 'of Northwatch', 'the Bold', 'the Ironhand'],
                Angel: ['of Dawn', 'the Radiant', 'the Merciful', 'of Eternal Light', 'the Seraphic'],
                Aliens: ['of Sector IX', 'from the Outer Rim', 'the Starborn', 'Prime', 'the Unknown'],
                Centaurs: ['Hoof of Storms', 'the Meadow Guard', 'of Oak Plains', 'the Longstride', 'the Archer'],
                Demons: ['the Corruptor', 'of the Ash Pit', 'the Cruel', 'the Unbound', 'the Tormentor'],
                Dragons: ['Flameborn', 'the Ancient', 'of Ember Peak', 'Sky Tyrant', 'the Molten'],
                Elves: ['of Silvergrove', 'Moon Whisper', 'Starweaver', 'the Graceful', 'Leafcaller'],
                Fairies: ['of Dewlight', 'the Tiny Bright', 'Petal Dancer', 'of Spring Bloom', 'the Luminous'],
                Giants: ['Stonebreaker', 'of High Crag', 'the Mountain', 'Hammerheart', 'the Colossal'],
                Gnomes: ['Gearspinner', 'of Copperhill', 'the Clever', 'Clockmind', 'Sparkfiddle'],
                Goblins: ['Mud Sneak', 'the Cunning', 'of Scrap Pit', 'Toothgrin', 'the Quick'],
                Imps: ['the Trickster', 'of Cinder Alley', 'Snap Tail', 'the Sneaky', 'the Flicker'],
                Merfolk: ['of Coral Bay', 'Wave Singer', 'the Deepborn', 'Pearl Keeper', 'Tide Caller'],
                Ogres: ['the Club', 'of Mire Bog', 'the Heavy', 'Bog Stomper', 'the Brutal'],
                Orks: ['Skull Cleaver', 'the Warlord', 'of Iron Camp', 'the Ruthless', 'Rageborn'],
                Pixies: ['Duststep', 'the Glitter', 'of Moonpetal', 'Twinkle Wing', 'the Tiny'],
                'Sea monsters': ['from the Abyss', 'the Drowned', 'of Dark Tides', 'the Maw', 'Brine Terror'],
                Trolls: ['Bridge Keeper', 'of Moss Cave', 'the Gruff', 'Stump Crusher', 'the Rugged'],
                Unicorns: ['of Crystal Meadow', 'the Gentle', 'Starlit Hoof', 'the Pure', 'Rainbow Crest'],
                Vampires: ['of Crimson Hall', 'the Eternal', 'Night Whisper', 'the Pale', 'Blood Regent'],
                Werewolves: ['Moon Hunter', 'the Feral', 'of Winter Forest', 'Claw Runner', 'the Howl'],
                'Witches / Wizards': ['of Arcane Tower', 'Spellweaver', 'Rune Keeper', 'the Wise', 'of Mystic Vale'],
                Yeties: ['of Frozen Spine', 'Snow Roarer', 'the White Fang', 'Blizzard Walker', 'Ice Climber'],
                Zombies: ['of the Grave', 'the Restless', 'Crypt Walker', 'the Hollow', 'Ash Stalker'],
                Pirate: ['of Black Tide', 'the Raider', 'Cutlass Hand', 'Storm Sailor', 'the Buccaneer'],
                Ship: ['of the North Sea', 'the Unbroken', 'of the Crimson Ocean', 'the Swift Sail', 'of Storm Water'],
                Kingdom: ['the Golden Realm', 'of the High Crown', 'the Old Throne', 'the Eternal Seat', 'of Seven Keeps'],
                Country: ['the Great Union', 'of Endless Plains', 'the Free Lands', 'the High Fields', 'of Wide Rivers'],
                City: ['the Old Gate', 'of Merchant Square', 'the Harbor Light', 'of Seven Towers', 'the Walled'],
                Town: ['the Riverside', 'of Windy Hollow', 'the Little Market', 'of Green Fields', 'the Quiet']
            };

            function createCategoryPills() {
                const grid = document.getElementById('categoriesGrid');
                grid.innerHTML = '';

                CATEGORY_NAMES.forEach((name) => {
                    const button = document.createElement('button');
                    button.type = 'button';
                    button.className = 'category-pill';
                    button.textContent = name;
                    button.setAttribute('data-category', name);

                    button.addEventListener('click', function () {
                        toggleCategory(name, button);
                    });

                    grid.appendChild(button);
                });
            }

            function toggleCategory(categoryName, button) {
                if (selectedCategories.has(categoryName)) {
                    selectedCategories.delete(categoryName);
                    button.classList.remove('active');
                } else {
                    selectedCategories.add(categoryName);
                    button.classList.add('active');
                }
                updateSelectedCount();
            }

            function updateSelectedCount() {
                const count = selectedCategories.size;
                document.getElementById('selectedCount').textContent = count + (count === 1 ? ' category selected' : ' categories selected');
            }

            function getGenderValue() {
                const selected = document.querySelector('input[name="gender"]:checked');
                return selected ? selected.value : 'both';
            }

            function sanitizeCount(value) {
                let count = parseInt(value, 10);
                if (isNaN(count)) {
                    count = 10;
                }
                if (count < 1) {
                    count = 1;
                }
                if (count > 100) {
                    count = 100;
                }
                return count;
            }

            function pickRandom(arr) {
                return arr[Math.floor(Math.random() * arr.length)];
            }

            function capitalizeWords(text) {
                return text
                    .split(' ')
                    .map((word) => word.charAt(0).toUpperCase() + word.slice(1))
                    .join(' ');
            }

            function buildSyllables(category, gender) {
                const source = SYLLABLE_BANK[category];
                const neutralPool = source.neutral.slice();

                if (gender === 'male') {
                    return source.male.concat(neutralPool);
                }
                if (gender === 'female') {
                    return source.female.concat(neutralPool);
                }
                return source.male.concat(source.female).concat(neutralPool);
            }

            function createBaseName(category, gender) {
                const pool = buildSyllables(category, gender);
                const partsCount = Math.random() < 0.5 ? 2 : 3;
                let name = '';

                for (let i = 0; i < partsCount; i++) {
                    name += pickRandom(pool);
                }

                name = capitalizeWords(name);
                if (Math.random() < 0.4) {
                    name += ' ' + pickRandom(CATEGORY_TITLES[category]);
                }
                return name;
            }

            // Anti-repetition: keep names unique in the same generation using retries + deterministic suffix fallback.
            function generateUniqueNames(category, gender, amount, usedGlobalNames) {
                const categoryNames = [];
                const localUsed = new Set();
                const maxAttempts = amount * 30;
                let attempts = 0;

                while (categoryNames.length < amount && attempts < maxAttempts) {
                    attempts++;
                    const candidate = createBaseName(category, gender);
                    if (!localUsed.has(candidate) && !usedGlobalNames.has(candidate)) {
                        localUsed.add(candidate);
                        usedGlobalNames.add(candidate);
                        categoryNames.push(candidate);
                    }
                }

                let suffixCounter = 1;
                while (categoryNames.length < amount) {
                    const candidate = createBaseName(category, gender) + ' ' + suffixCounter;
                    suffixCounter++;
                    if (!localUsed.has(candidate) && !usedGlobalNames.has(candidate)) {
                        localUsed.add(candidate);
                        usedGlobalNames.add(candidate);
                        categoryNames.push(candidate);
                    }
                }

                return categoryNames;
            }

            function buildSummary(total, categories) {
                if (categories.length === 1) {
                    return total + ' fantasy names were generated for ' + categories[0] + '.';
                }

                if (categories.length === 2) {
                    return total + ' fantasy names were generated for ' + categories[0] + ' and ' + categories[1] + '.';
                }

                const last = categories[categories.length - 1];
                const firstPart = categories.slice(0, -1).join(', ');
                return total + ' fantasy names were generated for ' + firstPart + ' and ' + last + '.';
            }

            function renderResults(items) {
                const cardsEl = document.getElementById('resultsCards');
                const listEl = document.getElementById('resultsList');

                cardsEl.innerHTML = '';
                listEl.innerHTML = '';

                if (items.length <= 20) {
                    listEl.classList.add('none');
                    items.forEach((item) => {
                        const card = document.createElement('div');
                        card.className = 'name-card';
                        card.innerHTML = '<span class="category">' + item.category + '</span>' + item.name;
                        cardsEl.appendChild(card);
                    });
                } else {
                    listEl.classList.remove('none');
                    items.forEach((item) => {
                        const li = document.createElement('li');
                        li.textContent = item.name + ' (' + item.category + ')';
                        listEl.appendChild(li);
                    });
                }
            }

            function buildPlainOutput(items, summaryText) {
                const lines = [summaryText, ''];
                items.forEach((item, index) => {
                    lines.push((index + 1) + '. ' + item.name + ' [' + item.category + ']');
                });
                return lines.join('\n');
            }

            function generateNames() {
                const quantityInput = document.getElementById('namesPerCategory');
                const namesPerCategory = sanitizeCount(quantityInput.value);
                quantityInput.value = namesPerCategory;

                const categories = Array.from(selectedCategories);
                const summaryEl = document.getElementById('summary');
                const resultTools = document.getElementById('resultTools');

                if (categories.length === 0) {
                    summaryEl.classList.remove('none');
                    summaryEl.textContent = 'Select at least one category before generating names.';
                    resultTools.classList.add('none');
                    document.getElementById('resultsCards').innerHTML = '';
                    document.getElementById('resultsList').innerHTML = '';
                    document.getElementById('resultsList').classList.add('none');
                    document.getElementById('plainOutput').textContent = '';
                    generatedItems = [];
                    return;
                }

                const gender = getGenderValue();
                const allNamesUsed = new Set();
                const results = [];

                categories.forEach((category) => {
                    const names = generateUniqueNames(category, gender, namesPerCategory, allNamesUsed);
                    names.forEach((name) => {
                        results.push({ category: category, name: name });
                    });
                });

                generatedItems = results;
                const total = results.length;
                const summaryText = buildSummary(total, categories);

                summaryEl.classList.remove('none');
                summaryEl.textContent = summaryText;

                renderResults(results);

                const plainOutputText = buildPlainOutput(results, summaryText);
                document.getElementById('plainOutput').textContent = plainOutputText;
                resultTools.classList.remove('none');
            }

            function downloadOutput() {
                if (!generatedItems.length) {
                    return;
                }
                const text = document.getElementById('plainOutput').textContent;
                download('fantasy-names.txt', text);
            }

            function clearResults() {
                generatedItems = [];
                document.getElementById('summary').classList.add('none');
                document.getElementById('summary').textContent = '';
                document.getElementById('resultTools').classList.add('none');
                document.getElementById('resultsCards').innerHTML = '';
                document.getElementById('resultsList').innerHTML = '';
                document.getElementById('resultsList').classList.add('none');
                document.getElementById('plainOutput').textContent = '';
            }

            function presetInitialGeneration() {
                const defaultCategory = 'Dragons';
                selectedCategories.add(defaultCategory);
                const button = document.querySelector('[data-category="' + defaultCategory + '"]');
                if (button) {
                    button.classList.add('active');
                }
                updateSelectedCount();
                generateNames();
            }

            createCategoryPills();
            updateSelectedCount();
            presetInitialGeneration();
        </script></p>
<p>The post <a href="https://imediacto.com/tools/name-generators/fantasy-name-generator/">Fantasy Name Generator</a> appeared first on <a href="https://imediacto.com">Free Online Tools - Imediacto</a>.</p>
]]></content:encoded>
					
					<wfw:commentRss>https://imediacto.com/tools/name-generators/fantasy-name-generator/feed/</wfw:commentRss>
			<slash:comments>0</slash:comments>
		
		
			</item>
	</channel>
</rss>
