<?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>Free Online Tools &#8211; Imediacto</title>
	<atom:link href="https://imediacto.com/feed/" rel="self" type="application/rss+xml" />
	<link>https://imediacto.com/</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>Free Online Tools &#8211; Imediacto</title>
	<link>https://imediacto.com/</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>
		<item>
		<title>REM to PX Converter</title>
		<link>https://imediacto.com/tools/rem-to-px-converter/</link>
					<comments>https://imediacto.com/tools/rem-to-px-converter/#respond</comments>
		
		<dc:creator><![CDATA[Dante]]></dc:creator>
		<pubDate>Thu, 28 May 2026 22:27:09 +0000</pubDate>
				<category><![CDATA[HTML Tools]]></category>
		<category><![CDATA[Tools]]></category>
		<guid isPermaLink="false">https://imediacto.com/?p=395</guid>

					<description><![CDATA[<p>Convert REM (Root Em) units to PX (Pixels). This tool is useful for frontend developers working with responsive design and font sizing.</p>
<p>The post <a href="https://imediacto.com/tools/rem-to-px-converter/">REM to PX Converter</a> appeared first on <a href="https://imediacto.com">Free Online Tools - Imediacto</a>.</p>
]]></description>
										<content:encoded><![CDATA[<p><div class="boot rem-to-px-converter">
			<div class="row mb-3">
				<div class="col-sm-12">
					<h2>Converting REM to PX and PX to REM</h2>
					<p>
						The <strong>REM to PX Converter</strong> is a <strong>CSS unit converter</strong> tool that helps you
						<strong>convert REM (Root Em) units to PX (Pixels)</strong> and vice versa. This tool is especially useful
						for frontend developers and designers who work with responsive design, as it helps convert between relative
						and absolute units. Simply input your value, set the base font size, and the conversion happens instantly.
					</p>
				</div>
			</div>

			<div class="base-font-section">
				<label for="baseFontSize">Base Font Size (REM root/default):</label>
				<input type="number" id="baseFontSize" value="16" min="8" max="32" step="0.5"
					placeholder="Base font size in pixels" onchange="updateConversions()">
				<span class="help-text mt-2">Default is 16px. Adjust this value if your root font-size is different.</span>
			</div>

			<div class="converter-section">
				<!-- REM to PX Column -->
				<div class="converter-column">
					<h3>REM to PX</h3>
					<div class="row">
						<div class="col-sm-12 mb-3">
							<label for="remInput">Enter REM value:</label>
							<input type="number" id="remInput" class="mb-2" placeholder="e.g., 1.5" step="0.1"
								oninput="convertRemToPx()">
							<div class="conversion-result mb-2">
								<span id="pxOutput">0</span> px
							</div>
							<div class="flex">
								<button class="soft mr-1" onclick="copyToClipboard('pxOutput', 'checkRemPx')" title="Copy REM to PX conversion to clipboard">
									<i class="fa fa-copy"></i>
									Copy
								</button>
								<div id="checkRemPx" class="check none"></div>
							</div>
						</div>
					</div>

					<div class="info-box">
						<strong>Formula:</strong> PX = REM × Base Font Size<br>
						Example: 1rem × 16px = 16px
					</div>
				</div>

				<!-- PX to REM Column -->
				<div class="converter-column">
					<h3>PX to REM</h3>
					<div class="row">
						<div class="col-sm-12 mb-3">
							<label for="pxInput">Enter PX value:</label>
							<input type="number" id="pxInput" class="mb-2" placeholder="e.g., 24" step="1"
								oninput="convertPxToRem()">
							<div class="conversion-result mb-2">
								<span id="remOutput">0</span> rem
							</div>
							<div class="flex">
								<button class="soft mr-1" onclick="copyToClipboard('remOutput', 'checkPxRem')" title="Copy PX to REM conversion to clipboard">
									<i class="fa fa-copy"></i>
									Copy
								</button>
								<div id="checkPxRem" class="check none"></div>
							</div>
						</div>
					</div>

					<div class="info-box">
						<strong>Formula:</strong> REM = PX ÷ Base Font Size<br>
						Example: 24px ÷ 16px = 1.5rem
					</div>
				</div>
			</div>

			<hr>

			<div class="more-notes entry-content">
				<h2>What is REM and PX in CSS?</h2>
				<p>
					<strong>PX (Pixels)</strong> is an absolute unit of measurement in CSS. One pixel is always the same size,
					regardless of the parent element or screen size. Pixels are fixed and do not scale, making them useful for
					precise layouts but less flexible for responsive design.
				</p>
				<p>
					<strong>REM (Root Em)</strong> is a relative unit of measurement in CSS. It is always relative to the root
					element's font size (usually the <code>&lt;html&gt;</code> element). By default, the root font size is 16px,
					so 1rem = 16px. REM units are scalable and responsive, making them ideal for modern web development.
				</p>

				<h3>Why Use REM Instead of PX?</h3>
				<ul>
					<li><strong>Responsive Design:</strong> REM values scale based on the root font size, making it easier to
						create responsive layouts.</li>
					<li><strong>Better Accessibility:</strong> Users who have set a custom base font size in their browser will
						see properly scaled text.</li>
					<li><strong>Easier Maintenance:</strong> Changing the root font size updates all REM-based values throughout
						your site.</li>
					<li><strong>Better for Typography:</strong> Line heights, margins, and paddings scale together when using REM.</li>
				</ul>

				<h3>Common Conversions</h3>
				<table>
					<tr>
						<th>REM</th>
						<th>PX (16px base)</th>
						<th>Usage</th>
					</tr>
					<tr>
						<td>0.5rem</td>
						<td>8px</td>
						<td>Small text, helper text</td>
					</tr>
					<tr>
						<td>0.75rem</td>
						<td>12px</td>
						<td>Smaller text</td>
					</tr>
					<tr>
						<td>1rem</td>
						<td>16px</td>
						<td>Base font size, body text</td>
					</tr>
					<tr>
						<td>1.25rem</td>
						<td>20px</td>
						<td>Normal text</td>
					</tr>
					<tr>
						<td>1.5rem</td>
						<td>24px</td>
						<td>Headings, larger text</td>
					</tr>
					<tr>
						<td>2rem</td>
						<td>32px</td>
						<td>Large headings</td>
					</tr>
					<tr>
						<td>2.5rem</td>
						<td>40px</td>
						<td>Very large headings</td>
					</tr>
					<tr>
						<td>3rem</td>
						<td>48px</td>
						<td>Page titles</td>
					</tr>
				</table>

				<h3>Example CSS Code</h3>
				<pre style="background-color: #f5f5f5; padding: 15px; border-radius: 4px; overflow-x: auto;">
/* Setting the root font size to 16px (default in most browsers) */
html {
  font-size: 16px;
}

/* Using REM for responsive spacing */
body {
  font-size: 1rem;      /* 16px */
  line-height: 1.5rem;  /* 24px */
}

h1 {
  font-size: 2rem;      /* 32px */
  margin-bottom: 1.5rem; /* 24px */
}

h2 {
  font-size: 1.5rem;    /* 24px */
  margin-bottom: 1rem;  /* 16px */
}

.button {
  padding: 0.75rem 1.5rem;  /* 12px 24px */
  font-size: 1rem;          /* 16px */
}
				</pre>
			</div>

			<div class="notes">
				<div class="image"></div>
				<div class="message">
					<p>
						Send me your feedback about this <strong>REM to PX converter</strong> and let me know if you have some
						specific need, then I can implement this new feature and improve this online tool. Also, let me know if
						you have some need about other different <strong>CSS tool</strong> or <strong>coding tool set</strong>.
					</p>
					<p>
						You can learn about how this online tool works or contribute improving the REM to PX Converter by
						programming some new feature or fixing bugs. For that, go to Github on <a
							href="https://github.com/dantovsky/Imediacto-Online-Tool-Set">Imediacto-Online-Tool-Set
							repository</a>. Any contribution is welcome and very appreciated. Thank you!
					</p>
				</div>
			</div>
		</div><!-- end .boot -->

		<script>
			function convertRemToPx() {
				const remValue = parseFloat(document.getElementById('remInput').value) || 0;
				const baseFont = parseFloat(document.getElementById('baseFontSize').value) || 16;
				const pxValue = (remValue * baseFont).toFixed(2);
				document.getElementById('pxOutput').textContent = pxValue;
			}

			function convertPxToRem() {
				const pxValue = parseFloat(document.getElementById('pxInput').value) || 0;
				const baseFont = parseFloat(document.getElementById('baseFontSize').value) || 16;
				const remValue = (pxValue / baseFont).toFixed(4);
				document.getElementById('remOutput').textContent = remValue;
			}

			function updateConversions() {
				convertRemToPx();
				convertPxToRem();
			}
		</script></p>
<p>The post <a href="https://imediacto.com/tools/rem-to-px-converter/">REM to PX Converter</a> appeared first on <a href="https://imediacto.com">Free Online Tools - Imediacto</a>.</p>
]]></content:encoded>
					
					<wfw:commentRss>https://imediacto.com/tools/rem-to-px-converter/feed/</wfw:commentRss>
			<slash:comments>0</slash:comments>
		
		
			</item>
		<item>
		<title>How to Compare Two Lists Online</title>
		<link>https://imediacto.com/blog/how-to-compare-two-lists-online/</link>
					<comments>https://imediacto.com/blog/how-to-compare-two-lists-online/#respond</comments>
		
		<dc:creator><![CDATA[Dante]]></dc:creator>
		<pubDate>Tue, 04 Nov 2025 00:36:26 +0000</pubDate>
				<category><![CDATA[Tech Blog]]></category>
		<category><![CDATA[List comparison tool]]></category>
		<guid isPermaLink="false">https://imediacto.com/?p=382</guid>

					<description><![CDATA[<p>Easily compare two lists online with this free tool. Find duplicates, differences, and matching items in seconds — no installation or signup required.</p>
<p>The post <a href="https://imediacto.com/blog/how-to-compare-two-lists-online/">How to Compare Two Lists Online</a> appeared first on <a href="https://imediacto.com">Free Online Tools - Imediacto</a>.</p>
]]></description>
										<content:encoded><![CDATA[<h2>How to Compare Two Lists Online?</h2>
<p>If you&#8217;ve ever had <strong>two large lists</strong> — of names, products, emails, or any other type of text — and needed to know <strong>what’s the same and what’s different</strong>, you know how tedious it can be to do it manually.</p>
<p>The good news is that you can do it <strong>in seconds</strong>, directly in your browser, with no installation required.<br />
In this article, you&#8217;ll learn <strong>how to compare two text lists online</strong> quickly and easily.</p>
<h3>Why Compare Lists?</h3>
<p>Comparing lists is useful in many everyday situations:</p>
<ul>
<li>Checking for <strong>duplicate emails</strong> before sending a newsletter.</li>
<li>Verifying if two lists of <strong>products or codes</strong> are in sync.</li>
<li>Finding <strong>differences between file versions</strong>.</li>
<li>Making sure one list contains <strong>all elements</strong> of another.</li>
</ul>
<p>It saves time and prevents mistakes that often happen when doing everything manually.</p>
<h3>How to Compare Lists Online (Step by Step)</h3>
<p>Follow this short guide to compare your lists directly in the browser:</p>
<h4>1. Access the List Comparison Tool</h4>
<p>Go to the <a class="decorated-link" href="https://imediacto.com/tools/list-tools/compare-two-lists/" rel="noopener"><strong>Compare Two Lists</strong></a> page here on <strong>Imediacto Free Online Tools</strong>.<br />
No sign-up or download required.</p>
<h4>2. Paste Your Lists</h4>
<p>In the tool, you&#8217;ll see <strong>two text boxes</strong>:</p>
<ul>
<li>In the <strong>List A</strong> field, paste your first list.</li>
<li>In the <strong>List B</strong> field, paste your second list.</li>
</ul>
<p>Each item should be on a separate line.</p>
<h4>3. Click “Apply diff” to Compare</h4>
<p>In just a few seconds, the system will analyze both lists and display:</p>
<ul>
<li>Items that appear <strong>only in List A</strong>;</li>
<li>Items that appear <strong>only in List B</strong>;</li>
<li>Items that <strong>exist in both lists (intersection);</strong></li>
<li>Items from <strong>both lists combined</strong> (union);</li>
<li>Items that <strong>exist only in List A</strong> plus items that <strong>exist only in List B</strong> (symmetric difference).</li>
</ul>
<h4>4. Review and Export the Results</h4>
<p>You can perform several actions:</p>
<ul>
<li>Sort each of the resulting lists;</li>
<li>Copy the result of any of these operations.</li>
</ul>
<h3>Extra Tip: Use “Clean Lists”</h3>
<p>For faster processing and more accurate results:</p>
<ul>
<li>Remove unnecessary spaces before pasting your lists.</li>
<li>Use plain text only (no headers, columns, or formulas).</li>
</ul>
<h3>Conclusion</h3>
<p>Comparing two lists online is a simple task that can save you <strong>a lot of time and headaches</strong>.<br />
With the <a class="decorated-link" href="https://imediacto.com/tools/list-tools/compare-two-lists/" rel="noopener"><strong>List Comparison Tool</strong></a>, you can quickly identify what’s changed between two lists — easily and for free.</p>
<p>Try it now and see how simple it is to find differences between two lists in just seconds.</p>
<p>The post <a href="https://imediacto.com/blog/how-to-compare-two-lists-online/">How to Compare Two Lists Online</a> appeared first on <a href="https://imediacto.com">Free Online Tools - Imediacto</a>.</p>
]]></content:encoded>
					
					<wfw:commentRss>https://imediacto.com/blog/how-to-compare-two-lists-online/feed/</wfw:commentRss>
			<slash:comments>0</slash:comments>
		
		
			</item>
		<item>
		<title>Ranking on Google Search – A Step by Step SEO Guide</title>
		<link>https://imediacto.com/blog/ranking-on-google-search/</link>
					<comments>https://imediacto.com/blog/ranking-on-google-search/#respond</comments>
		
		<dc:creator><![CDATA[Dante]]></dc:creator>
		<pubDate>Thu, 20 Feb 2025 11:09:31 +0000</pubDate>
				<category><![CDATA[Tech Blog]]></category>
		<category><![CDATA[SEO Optimization]]></category>
		<guid isPermaLink="false">https://imediacto.com/?p=360</guid>

					<description><![CDATA[<p>Ranking on Google Search - on the first page - is essential for any website that wants to attract visitors, generate leads, and increase sales.</p>
<p>The post <a href="https://imediacto.com/blog/ranking-on-google-search/">Ranking on Google Search – A Step by Step SEO Guide</a> appeared first on <a href="https://imediacto.com">Free Online Tools - Imediacto</a>.</p>
]]></description>
										<content:encoded><![CDATA[<h2 data-start="74" data-end="351">How to Rank in Google Search?</h2>
<p><strong>Ranking on Google Search &#8211; on the first page &#8211;</strong> is essential for any website that wants to attract visitors, generate leads, and increase sales. However, achieving this <strong>requires more than just publishing content</strong>—it demands a strategic approach to <strong>Search Engine Optimization (SEO)</strong>.</p>
<p>In this guide, we’ll walk you through the key SEO techniques that can <strong>help your website climb the search rankings</strong>, including:<br />
✅ <strong>Keyword Research</strong> – Finding the best terms to target.<br />
✅ <strong>On-Page SEO</strong> – Optimizing content, meta tags, and site structure.<br />
✅ <strong>Technical SEO</strong> – Improving website speed, mobile usability, and security.<br />
✅ <strong>Off-Page SEO</strong> – Building high-quality backlinks and increasing domain authority.<br />
✅ <strong>Local SEO</strong> – Optimizing for location-based searches to attract nearby customers.</p>
<p>Each section is designed to provide <strong>practical, actionable insights</strong> that you can implement immediately to improve your site’s visibility. Whether you’re a business owner, blogger, or digital marketer, this guide will help you <strong>boost your rankings and drive organic traffic</strong>.</p>
<blockquote><p>🚀 <em>Looking for expert SEO assistance? <strong><a href="https://www.dantemarinho.com/consultor-seo-wordpress/" target="_blank" rel="noopener">Check out our SEO Cofnsulting Services at dantemarinho.com</a></strong> and let’s optimize your website for success!</em></p></blockquote>
<p data-start="0" data-end="55"><img fetchpriority="high" decoding="async" class="aligncenter wp-image-369 size-full" src="https://imediacto.com/wp-content/uploads/2025/02/seo-optimization-evolution.jpg" alt="Ranking on Google Search Graph Evolution" width="800" height="450" srcset="https://imediacto.com/wp-content/uploads/2025/02/seo-optimization-evolution.jpg 800w, https://imediacto.com/wp-content/uploads/2025/02/seo-optimization-evolution-480x270.jpg 480w" sizes="(min-width: 0px) and (max-width: 480px) 480px, (min-width: 481px) 800px, 100vw" /></p>
<h2 data-start="0" data-end="55">1️⃣ Why Ranking on Google Matters</h2>
<p data-start="57" data-end="504">In today’s digital landscape, simply having a website is not enough. If your website does not appear on the <strong data-start="165" data-end="189">first page of Google</strong>, it is practically invisible to potential customers. Google is the most widely used search engine in the world, processing <strong data-start="313" data-end="350">over 8.5 billion searches per day</strong>. This means that <strong data-start="368" data-end="430">ranking higher on Google can drive massive organic traffic</strong> to your website, increasing your chances of generating leads and sales.</p>
<p data-start="506" data-end="579">But <strong data-start="510" data-end="556">why does ranking on Google matter so much?</strong> Let’s break it down.</p>
<h3 data-start="581" data-end="618">The Power of Google Rankings</h3>
<p data-start="620" data-end="918">When a user searches for a product, service, or piece of information, they are more likely to click on one of the first three results. <strong data-start="755" data-end="842">Studies show that the first organic result in Google gets about 27.6% of all clicks</strong>, while the second and third positions receive significantly fewer clicks.</p>
<p data-start="920" data-end="1204">If your website ranks on the second page (or worse, beyond that), your chances of attracting organic traffic drop dramatically. <strong data-start="1048" data-end="1120">This is why investing in SEO (Search Engine Optimization) is crucial</strong>—it helps you climb the search rankings and gain visibility where it matters most.</p>
<h2 data-start="1211" data-end="1251">SEO: The Key to Higher Rankings</h2>
<p data-start="1253" data-end="1678">SEO is the process of <strong data-start="1275" data-end="1302">optimizing your website</strong> to improve its position on search engines like Google. It involves a combination of:<br data-start="1387" data-end="1390" />✅ <strong data-start="1392" data-end="1407">On-Page SEO</strong> – Optimizing content, meta tags, and site structure.<br data-start="1460" data-end="1463" />✅ <strong data-start="1465" data-end="1482">Technical SEO</strong> – Improving site speed, mobile-friendliness, and indexing.<br data-start="1541" data-end="1544" />✅ <strong data-start="1546" data-end="1562">Off-Page SEO</strong> – Building backlinks and increasing domain authority.<br data-start="1616" data-end="1619" />✅ <strong data-start="1621" data-end="1634">Local SEO</strong> – Optimizing for location-based searches.</p>
<p data-start="1680" data-end="1834">When done correctly, <strong data-start="1701" data-end="1831">SEO helps websites rank higher, attract the right audience, and drive consistent organic traffic without the need for paid ads</strong>.</p>
<h2 data-start="1947" data-end="1993">Why Businesses Need to Rank on Google</h2>
<p data-start="1995" data-end="2096">No matter what industry you are in, appearing at the top of search results brings several benefits:</p>
<h3 data-start="2098" data-end="2150">#1 Increased Visibility &amp; Brand Awareness</h3>
<p data-start="2151" data-end="2333">The higher your website ranks, the more people will see your brand. Even if they don’t click immediately, <strong data-start="2257" data-end="2288">brand exposure builds trust</strong>, making users more likely to return later.</p>
<h3 data-start="2335" data-end="2393">#2 More Targeted Traffic (Higher Quality Leads)</h3>
<p data-start="2394" data-end="2575">Ranking on Google ensures that your website is discovered by <strong data-start="2455" data-end="2503">people actively searching for what you offer</strong>. This means higher-quality traffic and better chances of conversions.</p>
<h3 data-start="2577" data-end="2612">#3 Competitive Advantage</h3>
<p data-start="2613" data-end="2831">If your competitors are ranking higher than you, they are getting the traffic (and customers) that you are missing out on. <strong data-start="2736" data-end="2773">SEO helps level the playing field</strong> and gives you a fighting chance to outrank competitors.</p>
<h3 data-start="2833" data-end="2886">#4 Long-Term Growth Without Paying for Ads</h3>
<p data-start="2887" data-end="3104">Unlike paid advertising, where traffic stops as soon as you stop spending, SEO provides <strong data-start="2975" data-end="3012">sustainable and long-term results</strong>. Once your website ranks well, it can continue bringing traffic for months or even years.</p>
<h2 data-start="3111" data-end="3155">How to Rank on Google: What’s Next?</h2>
<p data-start="3157" data-end="3307">Now that you understand the importance of ranking on Google, the next step is learning <strong data-start="3244" data-end="3276">how to optimize your website</strong> using proven SEO techniques.</p>
<p data-start="3309" data-end="3504">In the upcoming sections, we will cover <strong data-start="3349" data-end="3425">keyword research, on-page optimization, link building, and technical SEO</strong>—everything you need to improve your rankings and drive more organic traffic.</p>
<blockquote>
<p data-start="3506" data-end="3648">🚀 <em data-start="3509" data-end="3646">If you want expert help, check out our <strong data-start="3549" data-end="3601"><a href="https://www.dantemarinho.com/consultor-seo-wordpress/" rel="noopener" data-start="3551" data-end="3599">SEO Consulting Services at dantemarinho.com</a></strong> and let’s boost your website’s performance!</em></p>
</blockquote>
<p><img decoding="async" class="aligncenter wp-image-372 size-full" src="https://imediacto.com/wp-content/uploads/2025/02/seo-keyword-strategy.png" alt="SEO Keyword Strategy" width="1280" height="853" srcset="https://imediacto.com/wp-content/uploads/2025/02/seo-keyword-strategy.png 1280w, https://imediacto.com/wp-content/uploads/2025/02/seo-keyword-strategy-980x653.png 980w, https://imediacto.com/wp-content/uploads/2025/02/seo-keyword-strategy-480x320.png 480w" sizes="(min-width: 0px) and (max-width: 480px) 480px, (min-width: 481px) and (max-width: 980px) 980px, (min-width: 981px) 1280px, 100vw" /></p>
<h2>2️⃣ Understanding Google’s Ranking Factors</h2>
<p>If you want to <strong>rank higher on Google</strong>, you need to understand <strong>how Google’s algorithm works</strong> and what factors influence search rankings. While Google keeps its exact ranking algorithm secret, SEO experts have identified <strong>key ranking factors</strong> that determine where a website appears in search results.</p>
<p>Google’s primary goal is to provide <strong>the best possible experience</strong> for users by delivering <strong>relevant, high-quality content</strong>. To achieve this, its ranking system evaluates hundreds of factors, but we can break them down into four main categories:</p>
<h3><strong>#1 On-Page SEO: Content &amp; Relevance</strong></h3>
<p>On-page SEO refers to <strong>everything you can optimize within your website</strong> to make it more search-friendly. This includes:</p>
<h4><strong>🔹 High-Quality Content</strong></h4>
<p>Google prioritizes content that is:<br />
✅ <strong>Relevant</strong> – It must answer the user’s search intent.<br />
✅ <strong>Well-structured</strong> – Organized with proper headings (H1, H2, H3).<br />
✅ <strong>Unique</strong> – Avoid duplicate content.<br />
✅ <strong>Valuable</strong> – Solves a problem or provides new insights.</p>
<p>Content that is <strong>original, informative, and engaging</strong> ranks higher because it keeps users on the page longer and encourages interactions.</p>
<h4><strong>🔹 Keyword Optimization</strong></h4>
<p>Using the right keywords <strong>helps Google understand what your content is about</strong>. But keyword stuffing (overusing keywords unnaturally) can actually hurt rankings. Instead, follow these best practices:<br />
✔ Place keywords naturally in the <strong>title, headings, and first paragraph</strong>.<br />
✔ Use <strong>synonyms and related terms</strong> to improve relevance.<br />
✔ Focus on <strong>long-tail keywords</strong> to target specific search queries.</p>
<h4><strong>🔹 Meta Tags &amp; Descriptions</strong></h4>
<ul>
<li>The <strong>title tag</strong> is one of the most important ranking factors. It should be <strong>clear, engaging, and include the target keyword</strong>.</li>
<li>The <strong>meta description</strong> doesn’t directly impact rankings but can <strong>increase click-through rates (CTR)</strong>, which indirectly helps SEO.</li>
</ul>
<h4><strong>🔹 Internal Linking</strong></h4>
<p>Linking between pages within your website helps:<br />
✅ Improve user navigation.<br />
✅ Spread authority across pages.<br />
✅ Keep visitors on your site longer.</p>
<p>🔗 <em>Need help optimizing your website’s content? <strong><a href="https://www.dantemarinho.com/consultor-seo-wordpress/">Get expert SEO consulting at dantemarinho.com</a></strong>!</em></p>
<h3><strong>#2 Technical SEO: Website Performance &amp; Accessibility</strong></h3>
<p>Technical SEO focuses on <strong>optimizing your site’s infrastructure</strong> to improve user experience and search engine crawlability. Key aspects include:</p>
<h4><strong>🔹 Page Speed &amp; Performance</strong></h4>
<p>Google favors <strong>fast-loading websites</strong>. A delay of just <strong>1 second</strong> can reduce conversions by <strong>7%</strong>. To improve speed:</p>
<ul>
<li>Compress images and enable browser caching.</li>
<li>Use a <strong>fast hosting provider</strong>.</li>
<li>Minimize CSS and JavaScript files.</li>
</ul>
<h4><strong>🔹 Mobile-Friendliness (Responsive Design)</strong></h4>
<p>With Google’s <strong>mobile-first indexing</strong>, sites that are <strong>not mobile-friendly</strong> rank lower. Ensure your website:<br />
✔ Adapts to different screen sizes.<br />
✔ Loads quickly on mobile devices.<br />
✔ Has a user-friendly design for small screens.</p>
<h4><strong>🔹 Secure Website (HTTPS)</strong></h4>
<p>Google considers <strong>security a ranking factor</strong>. Websites with <strong>SSL certificates (HTTPS)</strong> are prioritized over those with <strong>HTTP</strong>, as they protect user data.</p>
<h4><strong>🔹 Structured Data (Schema Markup)</strong></h4>
<p>Schema markup helps <strong>search engines understand your content better</strong>, leading to:</p>
<ul>
<li>Rich snippets (star ratings, FAQs, product info).</li>
<li>Higher CTR in search results.</li>
</ul>
<p>🔗 <em>Want to improve your website’s technical SEO? <strong><a href="https://www.dantemarinho.com/consultor-seo-wordpress/">Let’s optimize your site at dantemarinho.com</a></strong>!</em></p>
<h3><strong>#3 Off-Page SEO: Authority &amp; Backlinks</strong></h3>
<p>Off-page SEO refers to factors <strong>outside your website</strong> that affect rankings, mainly <strong>backlinks and brand signals</strong>.</p>
<h4><strong>🔹 Backlinks: The Foundation of Authority</strong></h4>
<p>Google views backlinks as &#8220;votes of confidence&#8221; from other websites. However, <strong>quality matters more than quantity</strong>.</p>
<p>✔ <strong>High-quality backlinks</strong> come from <strong>relevant, authoritative sites</strong>.<br />
❌ <strong>Low-quality backlinks</strong> (spammy, paid, or irrelevant) can harm rankings.</p>
<h4><strong>🔹 Social Signals &amp; Brand Mentions</strong></h4>
<p>While social media activity doesn’t directly impact rankings, it helps by:</p>
<ul>
<li>Increasing brand awareness and website traffic.</li>
<li>Encouraging content sharing, which can lead to backlinks.</li>
</ul>
<h4><strong>🔹 Google Business Profile (for Local SEO)</strong></h4>
<p>If you have a local business, optimizing your <strong>Google My Business profile</strong> improves your chances of appearing in <strong>local search results and Google Maps</strong>.</p>
<p>🔗 <em>Want to build high-quality backlinks? <strong><a href="https://www.dantemarinho.com/consultor-seo-wordpress/">Check out our SEO link-building services at dantemarinho.com</a></strong>!</em></p>
<h3><strong>#4 User Experience (UX) &amp; Engagement Metrics</strong></h3>
<p>Google measures how users interact with your website to determine its value. These metrics impact rankings:</p>
<h4><strong>🔹 Click-Through Rate (CTR)</strong></h4>
<p>The higher your CTR, the more Google sees your page as relevant. Improve CTR by:</p>
<ul>
<li>Writing compelling <strong>title tags</strong> and <strong>meta descriptions</strong>.</li>
<li>Using <strong>numbers, power words, and emotional triggers</strong> in headlines.</li>
</ul>
<h4><strong>🔹 Bounce Rate &amp; Dwell Time</strong></h4>
<p>If visitors <strong>leave your site too quickly</strong>, Google assumes your page <strong>doesn’t meet user expectations</strong>.</p>
<ul>
<li>Use engaging visuals and easy-to-read formatting.</li>
<li>Provide clear answers <strong>above the fold</strong>.</li>
<li>Ensure <strong>fast-loading pages</strong> and <strong>good navigation</strong>.</li>
</ul>
<h4><strong>🔹 Core Web Vitals: </strong><strong data-start="104" data-end="154">Measuring Website Performance</strong></h4>
<p>Google evaluates <strong data-start="175" data-end="194">user experience</strong> based on three key performance metrics:</p>
<p data-start="238" data-end="437">✅ <strong data-start="240" data-end="274">Largest Contentful Paint (LCP)</strong> – Measures <strong data-start="286" data-end="309">loading performance</strong> by tracking the time it takes for the largest visible element on the page to load. A good LCP score is <strong data-start="413" data-end="434">under 2.5 seconds</strong>.<br />
✅ <strong data-start="441" data-end="476">Interaction to Next Paint (INP)</strong> – Replaces FID and measures <strong data-start="505" data-end="523">responsiveness</strong>, tracking how quickly a website reacts to user interactions (e.g., button clicks, form inputs). A good INP score should be <strong data-start="647" data-end="673">under 200 milliseconds</strong>.<br />
✅ <strong data-start="680" data-end="713">Cumulative Layout Shift (CLS)</strong> – Measures <strong data-start="725" data-end="745">visual stability</strong>, ensuring that elements don’t shift unexpectedly while the page loads. A good CLS score is <strong data-start="837" data-end="854">less than 0.1</strong>.</p>
<p data-start="859" data-end="1005">📌 <strong data-start="862" data-end="919">These Core Web Vitals directly impact Google rankings</strong>, so optimizing them is crucial for improving search visibility and user experience.</p>
<h3><strong>So&#8230; Ranking in Google Requires a Holistic SEO Strategy</strong></h3>
<p>Google uses <strong>hundreds of ranking factors</strong>, but focusing on <strong>high-quality content, strong backlinks, technical SEO, and user experience</strong> can <strong>significantly boost your rankings</strong>.</p>
<p>In the next section, we’ll cover <strong>how to find the best keywords for your website</strong>—one of the most critical steps in SEO.</p>
<p>🚀 <em>Want to rank higher? <strong><a href="https://www.dantemarinho.com/consultor-seo-wordpress/">I can help you with SEO Otimization</a></strong>!</em></p>
<p><img decoding="async" class="aligncenter wp-image-371 size-full" src="https://imediacto.com/wp-content/uploads/2025/02/search-keyword-in-browser.png" alt="Search Keyword in Browser" width="100%" srcset="https://imediacto.com/wp-content/uploads/2025/02/search-keyword-in-browser.png 550w, https://imediacto.com/wp-content/uploads/2025/02/search-keyword-in-browser-480x168.png 480w" sizes="(min-width: 0px) and (max-width: 480px) 480px, (min-width: 481px) 550px, 100vw" /></p>
<h2><strong>3️⃣ Keyword Research: The Foundation of SEO</strong></h2>
<p>When it comes to <strong>ranking on Google Search</strong>, one of the most critical steps is <strong>keyword research</strong>. Without targeting the right keywords, your content might not reach the audience searching for your products or services. Keyword research is the <strong>foundation of SEO</strong>, as it helps you understand <strong>how to rank higher on Google searches</strong> by identifying the terms and phrases people are actively searching for.</p>
<h3><strong>Why Keyword Research is Essential for Google Rankings</strong></h3>
<p>Google’s algorithm determines <strong>which pages appear at the top of search results</strong> based on <strong>relevance, authority, and user intent</strong>. By targeting the right keywords, you can:</p>
<p>✅ <strong>Increase your visibility on Google Search</strong> by aligning your content with what users are searching for.<br />
✅ <strong>Attract qualified traffic</strong>, ensuring that visitors to your site are genuinely interested in your content.<br />
✅ <strong>Improve conversion rates</strong>, as targeted traffic is more likely to take action (purchase, subscribe, or contact).<br />
✅ <strong>Outrank competitors</strong> by finding keyword opportunities they haven’t fully optimized for.</p>
<p>A well-executed keyword strategy is essential for <strong>improving your Google rankings</strong> and establishing your website as an authority in your niche.</p>
<h3><strong>Types of Keywords to Focus On</strong></h3>
<p>To create an effective keyword strategy, it’s important to understand the <strong>different types of keywords</strong> and how they impact your ranking on Google Search:</p>
<h4><strong>🔹 Short-Tail Keywords (Broad Searches)</strong></h4>
<ul>
<li>Example: <em>&#8220;SEO tips&#8221;, &#8220;digital marketing&#8221;, &#8220;WordPress sites&#8221;</em></li>
<li><strong>High search volume</strong> but also <strong>high competition</strong>.</li>
<li>More difficult to rank for, but useful for authority-building.</li>
</ul>
<h4><strong>🔹 Long-Tail Keywords (Specific Queries)</strong></h4>
<ul>
<li>Example: <em>&#8220;how to rank higher on Google searches for small businesses&#8221;</em>.</li>
<li><strong>Lower competition but highly targeted</strong> to user intent.</li>
<li>Often used by people <strong>closer to making a purchase or taking action</strong>.</li>
</ul>
<h4><strong>🔹 LSI Keywords (Latent Semantic Indexing)</strong></h4>
<ul>
<li>Related terms that <strong>support the main keyword</strong> and help Google understand the topic better.</li>
<li>Example: If your main keyword is <em>ranking on Google Search</em>, LSI keywords could include: <em>&#8220;SEO optimization&#8221;, &#8220;Google search ranking factors&#8221;, &#8220;on-page SEO&#8221;</em>.</li>
</ul>
<p>By strategically incorporating a mix of these keywords, you <strong>increase your chances of ranking higher on Google searches</strong> and attracting the right audience.</p>
<h3><strong>How to Find the Best Keywords for Ranking on Google Search</strong></h3>
<p>The next step is to <strong>identify high-impact keywords</strong> that match your content and audience. Here are some <strong>effective keyword research methods</strong>:</p>
<h3><strong>#1 Use Google’s Autocomplete &amp; Related Searches</strong></h3>
<ul>
<li>Start typing a keyword in Google and see what suggestions appear.</li>
<li>Check the <strong>&#8220;People Also Ask&#8221;</strong> and <strong>&#8220;Related Searches&#8221;</strong> sections for additional ideas.</li>
</ul>
<h3><strong>#2 Leverage Free &amp; Paid Keyword Research Tools</strong></h3>
<p>There are several tools that provide <strong>search volume, competition levels, and ranking difficulty</strong>:</p>
<ul>
<li><strong>Google Keyword Planner</strong> (free) – Best for finding search volume estimates.</li>
<li><strong>Ubersuggest</strong> – Useful for keyword difficulty and trend analysis.</li>
<li><strong>Ahrefs &amp; SEMrush</strong> – Advanced tools for competitor analysis and ranking predictions.</li>
</ul>
<h3><strong>#3 Analyze Competitor Keywords</strong></h3>
<ul>
<li>Identify what keywords <strong>your competitors are ranking for</strong> and see where you can gain an advantage.</li>
<li>Use <strong>Ahrefs, SEMrush, or Moz</strong> to analyze their top-ranking pages.</li>
</ul>
<h3><strong>#4 Focus on Search Intent</strong></h3>
<p>Understanding the <strong>user’s intent</strong> behind a keyword is crucial. Search queries generally fall into these categories:<br />
✔ <strong>Informational</strong> – Users looking for answers (<em>&#8220;how to rank higher on Google searches?&#8221;</em>).<br />
✔ <strong>Navigational</strong> – Users searching for a brand (<em>&#8220;Google Search ranking guide&#8221;</em>)<br />
✔ <strong>Transactional</strong> – Users ready to take action (<em>&#8220;best SEO consultant for ranking on Google Search&#8221;</em>)</p>
<p>By aligning your content with the <strong>right intent</strong>, you increase the chances of ranking higher and driving <strong>meaningful traffic</strong> to your website.</p>
<h3><strong>Where to Use Keywords for Maximum Impact</strong></h3>
<p>Once you’ve identified the best keywords, the next step is <strong>optimizing your website</strong> by placing them strategically. Here’s where they matter the most:</p>
<p>✅ <strong>Page Title &amp; Meta Description</strong> – The first thing users see in search results.<br />
✅ <strong>Headings (H1, H2, H3)</strong> – Helps Google understand the structure of your content.<br />
✅ <strong>First 100 Words</strong> – Ensures Google quickly detects the page’s topic.<br />
✅ <strong>Image Alt Text</strong> – Improves rankings for image search.<br />
✅ <strong>URL Structure</strong> – Clean, keyword-rich URLs help both users and search engines.<br />
✅ <strong>Internal Links</strong> – Strengthens keyword relevance across your site.</p>
<p>Proper keyword placement <strong>boosts your content’s visibility</strong> and <strong>improves the user experience</strong>, making it easier for Google to rank your pages.</p>
<h3><strong>Keep in Mind: Keyword Research is the Key to Ranking on Google Search</strong></h3>
<p>Mastering keyword research is <strong>one of the most important steps in SEO</strong>. By using the right tools, understanding search intent, and optimizing your content effectively, you can <strong>rank higher on Google searches</strong> and attract more targeted visitors.</p>
<p>🚀 <em>Need expert SEO guidance? <strong><a href="https://www.dantemarinho.com/consultor-seo-wordpress/">Check out our SEO services at dantemarinho.com</a></strong> and start improving your rankings today!</em></p>
<hr />
<p data-start="3506" data-end="3648"><strong>This page is under construction! So you can get the full information soon.</strong></p>
<p>The post <a href="https://imediacto.com/blog/ranking-on-google-search/">Ranking on Google Search – A Step by Step SEO Guide</a> appeared first on <a href="https://imediacto.com">Free Online Tools - Imediacto</a>.</p>
]]></content:encoded>
					
					<wfw:commentRss>https://imediacto.com/blog/ranking-on-google-search/feed/</wfw:commentRss>
			<slash:comments>0</slash:comments>
		
		
			</item>
		<item>
		<title>List Application of Artificial Intelligence</title>
		<link>https://imediacto.com/blog/list-application-of-artificial-intelligence/</link>
					<comments>https://imediacto.com/blog/list-application-of-artificial-intelligence/#respond</comments>
		
		<dc:creator><![CDATA[Dante]]></dc:creator>
		<pubDate>Sun, 12 Mar 2023 03:49:14 +0000</pubDate>
				<category><![CDATA[Tech Blog]]></category>
		<guid isPermaLink="false">https://imediacto.com/?p=345</guid>

					<description><![CDATA[<p>Artificial intelligence is one of the most transformative technologies of our time. With its ability to learn, reason, and make decisions, AI is changing the way businesses operate, governments govern, and people live their lives.</p>
<p>The post <a href="https://imediacto.com/blog/list-application-of-artificial-intelligence/">List Application of Artificial Intelligence</a> appeared first on <a href="https://imediacto.com">Free Online Tools - Imediacto</a>.</p>
]]></description>
										<content:encoded><![CDATA[<p><p>Artificial intelligence is one of the most transformative technologies of our time. With its ability to learn, reason, and make decisions, AI is changing the way businesses operate, governments govern, and people live their lives. As technology continues to advance, AI applications are becoming increasingly sophisticated and are being used across a wide variety of sectors and industries.</p>

    <p>These are just a few of the many AI applications that are transforming the way we live and work. As technology continues to evolve, we can expect to see even more exciting advances in the future.</p>
    
    <h2>List of AI applications with short explanation</h2>

    <div class="post-ai-apps">
        <div class="input-group">
            <div class="align-center">
                <p style="padding: 12px;">Search to filter</p>
            </div>
            <span class="input-group-addon" id="sizing-addon2"><span class="glyphicon glyphicon-filter" aria-hidden="true"></span></span>
            <input type="text" id="search" name="search" class="form-control" placeholder="Search AI application" aria-describedby="sizing-addon2">
        </div>
    
        <div>
            <div class="align-center">
                <p style="padding: 12px;">Filter by category</p>
            </div>
            <ul id="category-filter"></ul>
        </div>
    
        <div id="ai-listing">
            <div id="tools-loader">
                <div class="lds-ripple">
                    <div></div>
                    <div></div>
                </div>
            </div>
        </div>
    </div>

    <h2>Major areas of applications of artificial intelligence</h2>

    <p>One of the most important areas where AI is being used is in medicine. AI can be used to help doctors diagnose diseases, prescribe treatments, and monitor patient health. Additionally, AI is also being used to discover new drugs and therapies for complex diseases.</p>

    <p>Another sector where AI is having a big impact is the automotive industry. AI is being used to help create self-driving cars that can drive without the need for human intervention. This can help reduce the number of accidents on the road and make transportation more efficient and safe.</p>

    <p>AI is also being used to improve cybersecurity. With an increasing amount of data being generated and stored online, cybersecurity has become an important concern. AI can be used to identify security threats and prevent attacks before they happen.</p>

    <p>Another important application of AI is in finance. AI can be used to analyze financial data and predict market trends. This can help investors and financial institutions make informed decisions and reduce financial risks.</p>

    <div class="notes">
        <div class="image"></div>
        <div class="message">
            <p>
                Hello, this application provides an easy way to display and search artificial intelligence applications in a filterable list and is useful for anyone who wants to explore the possibilities of artificial intelligence.
            </p> 
            <p>
                If you found a mistake or would like to send me a new Artificial Intelligence application, you can indicate it through the comments below or create a pull request on <a href="https://github.com/dantovsky/Imediacto-Online-Tool-Set/blob/master/tools/blog/ai-applications-listing/apps.json" target="_blank">Github >> Artificial Intelligence JSON List</a> to add it directly to the JSON where all applications are contained.
            </p>
        </div>
    </div>

    <script>
    
        let categoryFilter = document.querySelector('ul#category-filter');
        let tools = document.querySelectorAll('.tool');

        // --------------------------------------------------------------------
        // Get AI applications list
        // --------------------------------------------------------------------

        jQuery(document).ready(function ($) {

        loadPosts();

        function loadPosts() {

            const version = "1.9" // updated on 29/08/2024
            const url = "https://raw.githubusercontent.com/dantovsky/Imediacto-Online-Tool-Set/master/tools/blog/ai-applications-listing/apps.json?v=" + version

            if (localStorage.imediactoAIApps && localStorage.imediactoAIAppsVersion && version == localStorage.imediactoAIAppsVersion) {

                const items = localStorage.getItem('imediactoAIApps')

                // Insert all items inside a div.tools and append to #ai-listing
                $("<div/>", {
                    "class": "tools",
                    html: items
                }).appendTo("#ai-listing");

                // Call other funcitons
                searchApplications()
                generatecateroryListFilterable()

                // Clear leader
                $('#tools-loader').fadeOut();

            } else {
                $.getJSON(url, function () {
                    // Success!
                }).done(function (data, status, request) {

                        // Array to store all posts
                        var items = []
                        for (var post in data) {

                            let item = {
                                id: 'id-' + nameToId(data[post].name),
                                name: data[post].name,
                                url: data[post].url,
                                description: data[post].description,
                                categories: data[post].categories
                            }
                        
                            let tool = `
                            <div id="${item.id}" class="jumbotron tool">
                                <h3>${item.name}</h3>
                                <div class="categories">`
                            item.categories.forEach(category => {
                                tool += `<span class="category">${category}</span>`
                            })
                            tool += `</div>
                                <p>${item.description}</p>
                                <a href="${item.url}" target="_blank" rel="nofollow">${item.url}</a>
                            </div>`
                            items.push(tool);
                        }

                        // Insert all items inside a div.tools and append to #ai-listing
                        $("<div/>", {
                            "class": "tools",
                            html: items.join("")
                        }).appendTo("#ai-listing");

                        // Saving on localStorage
                        localStorage.setItem('imediactoAIApps', items.join(""))
                        localStorage.setItem('imediactoAIAppsVersion', version)

                        // Call other funcitons
                        searchApplications()
                        generatecateroryListFilterable()

                    }).fail(function (error) {
                        $('#tabela tbody').html("Something went wrong when loading the data.");
                    }).always(function () {

                        // Clear leader
                        $('#tools-loader').fadeOut();
                    })
            }
        }
        });
        // https://api.jquery.com/jQuery.getJSON/
        // https://zellwk.com/blog/looping-through-js-objects/
        // https://stackoverflow.com/questions/26973570/setting-a-max-character-length-in-css/26975271

        // --------------------------------------------------------------------
        // Convert composed names to ID
        // --------------------------------------------------------------------

        function nameToId(name) {
            const id = name.toLowerCase().replace(/[^a-z0-9 ]/g, ""); // Converte para minúsculo e remove caracteres especiais
            return id.replace(/\s+/g, "-"); // Substitui espaços por hífens
        }
        
        // --------------------------------------------------------------------
        // Search apps
        // --------------------------------------------------------------------

        function searchApplications() {
            let searchInput = document.querySelector('#search');            

            searchInput = document.querySelector('#search');
            tools = document.querySelectorAll('.tool');

            searchInput.addEventListener('input', function(event) {

                const searchTerm = event.target.value.toLowerCase(); 

                tools.forEach(tool => {
                    const name = tool.querySelector('h3').textContent.toLowerCase();
                    const category = tool.querySelector('.category').textContent.toLowerCase();
                    const description = tool.querySelector('p').textContent.toLowerCase();
                    
                    if (name.includes(searchTerm) || category.includes(searchTerm) || description.includes(searchTerm)) {
                        tool.style.display = "";
                    } else {
                        tool.style.display = "none"
                    }
                });
            });
        }

        
        // --------------------------------------------------------------------
        // Category list selectable for filtering
        // --------------------------------------------------------------------

        function generatecateroryListFilterable() {
            // Obtém todas as categorias existentes
            const allCategories = Array.from(document.querySelectorAll('.tool .category')).map(span => span.textContent);

            // Remove duplicatas
            const uniqueCategories = [...new Set(allCategories)];

            // Cria a lista de categorias na classe "category-filter"
            uniqueCategories.forEach(category => {
                const li = document.createElement('li');

                li.classList.add('category')
                li.appendChild(document.createTextNode(category));
                categoryFilter.appendChild(li);
            });

            // Adiciona ouvinte de eventos à lista de categorias
            const liCategories = Array.from(categoryFilter.querySelectorAll('ul#category-filter li.category'));
            liCategories.forEach(liCategory => {
                liCategory.addEventListener('click', function() {
                    liCategory.classList.toggle('active');
                    filterTools(liCategories);
                });
            });
        }

        function filterTools(liCategories) {

            const activeCategories = liCategories.filter(liCategory => liCategory.classList.contains('active')).map(liCategory => liCategory.textContent);

            // Se nenhuma categoria estiver selecionada, exibe todas as ferramentas
            if (activeCategories.length === 0) {
                tools.forEach(tool => {
                    tool.style.display = 'block';
                });
                return;
            }
            
            // Remove todas as ferramentas da tela
            tools.forEach(tool => {
                tool.style.display = 'none';
            });

            // Filtra as ferramentas com base nas categorias ativas
            tools.forEach(tool => {
                const toolCategories = Array.from(tool.querySelectorAll('.category')).map(span => span.textContent);
                tool.style.display = activeCategories.some(category => toolCategories.includes(category)) ? 'block' : 'none';
            });
        }
    </script></p>
<p>The post <a href="https://imediacto.com/blog/list-application-of-artificial-intelligence/">List Application of Artificial Intelligence</a> appeared first on <a href="https://imediacto.com">Free Online Tools - Imediacto</a>.</p>
]]></content:encoded>
					
					<wfw:commentRss>https://imediacto.com/blog/list-application-of-artificial-intelligence/feed/</wfw:commentRss>
			<slash:comments>0</slash:comments>
		
		
			</item>
		<item>
		<title>Find and Replace Text Online</title>
		<link>https://imediacto.com/tools/text-tools/find-and-replace-text-online/</link>
					<comments>https://imediacto.com/tools/text-tools/find-and-replace-text-online/#respond</comments>
		
		<dc:creator><![CDATA[Dante]]></dc:creator>
		<pubDate>Sun, 11 Sep 2022 02:08:30 +0000</pubDate>
				<category><![CDATA[Text Tools]]></category>
		<category><![CDATA[Tools]]></category>
		<guid isPermaLink="false">https://imediacto.com/?p=334</guid>

					<description><![CDATA[<p>Use the Online Text Replacer Tool to find and replace text saving your time when you need to change some words in a large document.</p>
<p>The post <a href="https://imediacto.com/tools/text-tools/find-and-replace-text-online/">Find and Replace Text Online</a> appeared first on <a href="https://imediacto.com">Free Online Tools - Imediacto</a>.</p>
]]></description>
										<content:encoded><![CDATA[<p><div class="boot">
        <p>This is an <strong>online text replacer tool</strong> that allows you to find and replace text saving your time when you need to change some words in a large document.</p>
        
        <div class="row">
            <div class="col-sm-12 mb-3">
                <strong class="title">Input</strong>
                <textarea id="input" name="input" cols="30" rows="10" placeholder="Insert text to replace"></textarea>
            </div>
        </div>

        <div class="row">
            <div class="col-md-6 col-12 col-sm-12">
                <strong class="title">Search for</strong>
                <div class="form-group">
                    <input id="search" class="form-control mb-2 mr-sm-2" type="text" value=""
                        placeholder="Text to search for">
                </div>
            </div>
            <div class="col-md-6 col-12 col-sm-12">
                <strong class="title">Replace with</strong>
                <div class="form-group">
                    <input id="replace" class="form-control mb-2 mr-sm-2" type="text" value=""
                        placeholder="Text to replace with">
                </div>
            </div>
        </div>

        <div class="row">
            <div class="col-md-6 col-12 col-sm-12 mb-3">
                <strong class="title">Options</strong>
                <div class="custom-control custom-checkbox">
                    <input type="checkbox" id="case-sensitive" class="custom-control-input">
                    <label class="custom-control-label" for="case-sensitive">Math case-sensitive</label>
                </div>
                <div class="custom-control custom-checkbox">
                    <input type="checkbox" id="match-exact-word" class="custom-control-input" checked>
                    <label class="custom-control-label" for="match-exact-word">Math exact word / term</label>
                </div>
                <div class="custom-control custom-checkbox">
                    <input type="checkbox" id="first-occurrence" class="custom-control-input">
                    <label class="custom-control-label" for="first-occurrence">Find only first occurrence</label>
                </div>
            </div>
        </div>

        <div class="row">
            <div class="col-sm-12 mb-3">
                <button class="btn btn-success" onclick="findAndReplace();"
                    aria-label="Button to find and replace text">
                    <i class="fa fa-chevron-right"></i> Find and replace
                </button>
            </div>
            <div class="col-sm-12">
                <strong class="title">Output</strong>
                <div id="output"></div>
                <div class="flex" style="justify-content: space-between;">
                    <div class="flex mt-2">
                        <div class="div-btn mr-1" onclick="saveToFile()" title="Download as TXT"
                            aria-label="Button to download the output JSON"> <i class="fa fa-download">
                                <span>TXT</span></i>
                        </div>
                        <div class="flex">
                            <div class="div-btn" onclick="copyToClipboard()" title="Copy output to clipboard"
                                area-label="Button to copy the JSON to clipboard"> <i class="fa fa-copy"> <span
                                        class="hide-on-xs">Copy to clipboard</span></i></div>
                            <div id="check" class="none"
                                style="width: 18px; height: 18px; background-size: contain; margin-left: 8px; margin-bottom: 4px;">
                            </div>
                        </div>
                    </div>
                    <div id="num-occurrences" class="mt-2 float-right"></div>
                </div>
            </div>
        </div>

        <hr>

        <h2>How does the Find and Replace Text work?</h2>
        <p>To use this tool you need:</p>
        <ol>
            <li>In the <strong>Input</strong> textarea, type or paste a block of text you want to replace.</li>
            <li>In the <strong>Search for</strong> input, put the term you want to search for.</li>
            <li>In the <strong>Replace with</strong> input, put the term you want to replace for.</li>
            <li>Choose options to improve your search.</li>
            <li>Click the <strong>Find and replace</strong> button. Actually the process will be applyed automatically.</li>
            <li>Finally, you can see the resulting text in the <strong>Output</strong> textarea.</li>
        </ol>

        <div class="notes">
            <div class="image"></div>
            <div class="message">
                <p>
                    You can view the source code of this online tool or contribute to improving it
                    by programming some new feature or fixing bugs. For that, go to Github at <a
                        href="https://github.com/dantovsky/Imediacto-Online-Tool-Set/tree/master/tools/009-find-and-replace-text-online"
                        target="_blank">Github >> Find and Replace Text Online</a> and make a pull request. This will be
                    great!
                </p>
            </div>
    </div>
</div>

    <script>
        function findAndReplace() {

            const search = document.getElementById('search').value
            const replace = document.getElementById('replace').value

            if (search == '' || replace == '') {
                document.getElementById('output').innerHTML = ''
                return
            }

            const text = document.getElementById('input').value
            const isCaseSensitive = document.getElementById('case-sensitive').checked ? true : false
            const isMatchExactlyWord = document.getElementById('match-exact-word').checked ? true : false
            const isToFindFirstOccurrence = document.getElementById('first-occurrence').checked ? true : false

            const regex = new RegExp((isMatchExactlyWord ? '\\b' : '') + search + (isMatchExactlyWord ? '\\b' : ''), (isToFindFirstOccurrence ? '' : 'g') + (isCaseSensitive ? '' : 'i'))

            document.getElementById('output').innerHTML = text
                .replace(regex, '<mark>' + replace + '</mark>')
                .replace(/\n/g, '<br />')
            // console.log(text.match(regex))
            document.getElementById('num-occurrences').innerHTML = (text.match(regex) ? text.match(regex).length : '0') + (text.match(regex) && text.match(regex).length == 1 ? ' occurrence' : ' occurrences')
        }

        function saveToFile() {
            download('text-replaced.txt', document.getElementById('output').innerText)
        }

        document.getElementById('search').addEventListener('keyup', findAndReplace)
        document.getElementById('replace').addEventListener('keyup', findAndReplace)
        document.getElementById('case-sensitive').addEventListener('click', findAndReplace)
        document.getElementById('match-exact-word').addEventListener('click', findAndReplace)
        document.getElementById('first-occurrence').addEventListener('click', findAndReplace)
    </script></p>
<p>The post <a href="https://imediacto.com/tools/text-tools/find-and-replace-text-online/">Find and Replace Text Online</a> appeared first on <a href="https://imediacto.com">Free Online Tools - Imediacto</a>.</p>
]]></content:encoded>
					
					<wfw:commentRss>https://imediacto.com/tools/text-tools/find-and-replace-text-online/feed/</wfw:commentRss>
			<slash:comments>0</slash:comments>
		
		
			</item>
		<item>
		<title>XML, CSV, and JSON Data Formats in Practice</title>
		<link>https://imediacto.com/blog/xml-csv-json-data-formats/</link>
					<comments>https://imediacto.com/blog/xml-csv-json-data-formats/#respond</comments>
		
		<dc:creator><![CDATA[Dante]]></dc:creator>
		<pubDate>Sun, 14 Feb 2021 00:24:19 +0000</pubDate>
				<category><![CDATA[Tech Blog]]></category>
		<guid isPermaLink="false">https://imediacto.com/?p=284</guid>

					<description><![CDATA[<p>XML, CSV, and JSON Data Formats are organized informations according to predefined specifications used for data transfer and system communications and integrations.</p>
<p>The post <a href="https://imediacto.com/blog/xml-csv-json-data-formats/">XML, CSV, and JSON Data Formats in Practice</a> appeared first on <a href="https://imediacto.com">Free Online Tools - Imediacto</a>.</p>
]]></description>
										<content:encoded><![CDATA[<blockquote><p>In this article I will introduce you to <strong>XML vs CSV vs JSON data formats</strong> and show you, simply, how they are in practice.</p></blockquote>
<h2>What is Data Format?</h2>
<p>The <strong>Data format</strong> is the organization of information according to predefined specifications and is normally used for computer processing, that is, they are used for:</p>
<ul>
<li>System integrations</li>
<li>Data transfers</li>
<li>Data storage
<ul>
<li>Stored in files</li>
<li>Serialized to be stored in a database or in local storage of the browse or cache</li>
</ul>
</li>
</ul>
<p><strong>Data formats</strong> are used for communication between parts of a system or application, as well as for communication between independent systems. They are easily readable by humans and easy to programmatically manipulate.</p>
<h2>What is XML Data Format?</h2>
<p>XML (Extensible Markup Language) is a markup language that defines a set of rules for encoding hierarchically organized documents. The XML language is classified as extensible because it allows defining the markup elements.</p>
<p>A markup language is an aggregate of codes that can be applied to data or text to be read by computers or people. For example, HTML is a markup language designed to organize and format a website. XML has the same concept, but to standardize a sequence of data to organize, separate the content and integrate it with other languages.</p>
<p>The main characteristic of XML is the portability of information between computers and applications. For example, news feeds received via RSS using an XML file to structure the information.</p>
<p>Although XML is a very readable format, it has the drawback of being very bulky and may have tags, attributes, namespaces, and schemas. This means that it can eat up a lot of the bandwidth while transferring a small amount of data.</p>
<p>Example of an XML document:</p>
<pre><code class="xml">&lt;?xml version="1.0" encoding="UTF-8"?&gt;
&lt;firends&gt;
    &lt;friend&gt;
        &lt;name&gt;John Ferreira&lt;/name&gt;
        &lt;age&gt;26&lt;/age&gt;
        &lt;city&gt;Porto&lt;/city&gt;
        &lt;profession&gt;Full Stack Web Developer&lt;/profession&gt;
        &lt;hobby&gt;Fitness&lt;/hobby&gt;
    &lt;/friend&gt;
    &lt;friend&gt;
        &lt;name&gt;Leonardo Marinho&lt;/name&gt;
        &lt;age&gt;18&lt;/age&gt;
        &lt;city&gt;London&lt;/city&gt;
        &lt;profession&gt;Electric Engineer&lt;/profession&gt;
        &lt;hobby&gt;Build lego&lt;/hobby&gt;
    &lt;/friend&gt;
    &lt;friend&gt;
        &lt;name&gt;Caroline Azevedo&lt;/name&gt;
        &lt;age&gt;34&lt;/age&gt;
        &lt;city&gt;Salvador&lt;/city&gt;
        &lt;profession&gt;Entrepreneur&lt;/profession&gt;
        &lt;hobby&gt;Sing&lt;/hobby&gt;
    &lt;/friend&gt;
&lt;/friends&gt;</code></pre>
<h2>What is CSV Data Format?</h2>
<p>The CSV (Comma-separated Values) is a format used for the representation of tabular data, widely used in database import/export and spreadsheet applications. Commonly, SQL database systems, like MySQL Workbench, SQL Server, and PhpMyAdmin, support importing and exporting data as CSV.</p>
<p>In other words, CSV is a plain text format delimited by lines where each line is a data record. Each record consists of one or more fields, separated by commas. Usually, the first line of the CSV is the header for the data of the remaining lines.</p>
<p>It&#8217;s easy to read and write by humans, and easy to interpret by computers. Programmatically a system can read all lines from a CSV and for each line split values between commas characters.</p>
<p>Example of a CSV data format:</p>
<pre><code class="csv">name, age, city, profession, hobby
John Ferreira, 26, Porto, Full Stack Web Developer, Fitness
Leonardo Marinho, 18, London, Electric Engineer, Build lego
Caroline Azevedo, 34, Salvador, Entrepreneur, Sing
</code></pre>
<p>It is easy to see that CSV files take up much less storage space, as their structure is simple and small, so it is also great for streaming large volumes of data.</p>
<h2>What is JSON Data Format?</h2>
<p>JSON (JavaScript Object Notation) is a compact data format used for simple and fast data exchange between systems, and its basic structural unit is based on key-value pair.</p>
<p>A value can be one of the following data type or structure, and these structures can be nested:</p>
<ul>
<li>string in double quotes</li>
<li>number</li>
<li>object</li>
<li>array</li>
<li>boolean (true or false)</li>
<li>null</li>
</ul>
<p>See the <a href="https://www.json.org/json-en.html" target="_blank" rel="noopener">json.org</a> to get a full detail about JSON structure.</p>
<p>JSON is a JavaScript-based format, one of the most popular programming languages in the world. It has become very popular when using APIs and configuration files, such as <code>package.json</code>, which is created when we use NPM to manage the dependencies of a JavaScript project.</p>
<p>Example of a JSON data format:</p>
<pre><code class="json">{
    "friends":
    [
        {
            "name": "John Ferreira",
            "age": 26,
            "city": "Porto",
            "profession": "Full Stack Web Developer",
            "hobbies": ["Fitness", "Games"]
        },
        {
            "name": "Leonardo Marinho",
            "age": 18,
            "city": "London",
            "profession": "Electric Engineer",
            "hobbies": ["Build legos", "Robots", "Swim"]
        },
        {
            "name": "Caroline Azevedo",
            "age": 34,
            "city": "Salvador",
            "profession": "Entrepreneur",
            "hobbies": ["Sing", "play guitar"]
        }
    ]
}
</code></pre>
<p>Each item in the friends list is an <strong>object</strong>, just as we write objects in JavaScript. We say it is a self-contained document because for each object (a friend) we describe the <strong>keys</strong> and their <strong>values</strong>. Here is an example of a single item in the list, which is nothing more than a JSON object with all the necessary information for the item:</p>
<pre><code class="json">{
    "name": "John Ferreira",
    "age": 26,
    "city": "Porto",
    "profession": "Full Stack Web Developer",
    "hobby": "Fitness"
}
</code></pre>
<p>This becomes both a positive and a negative point:</p>
<ul>
<li>Positive point: we have all the information we need in a single piece of code.</li>
<li>Negative point: we have code repetition and therefore more bandwidth data transfer consumption and more space needed for storage. Obviously, this point is only of concern if we are working with large volumes of data, as in Big Data.</li>
</ul>
<p>Currently, JSON is the most used data type among developers. We can obtain proof of this by analyzing the volume of demand for the three formats (XML, CSV, and JSON) over several years, through Google Trends.</p>
<figure class="figure"><img decoding="async" class="figure-img img-fluid rounded" src="https://imediacto.com/wp-content/uploads/2021/02/json-csv-xml-comparison.png" alt="JSON, CSV and XML comparison" /></figure>
<p><a href="https://trends.google.com/trends/explore?date=2010-01-01%202021-01-01&amp;q=JSON,CSV,XML" target="_blank" rel="nofollow noopener">JSON, CSV, and XML comparison</a></p>
<p>As we can see, XML was widely used in the past, but JSON maintains a position far ahead of others. In turn, CSV is also in constant and growing demand, despite not having a large volume like JSON.</p>
<p>Now, I&#8217;m curious to try to understand why both three formats had a drop in demand since September 2020. Would you have an opinion?</p>
<h2>Conversion of Data Formats</h2>
<p>The need to convert between types of data has become very common, a fact that we can also certify through Google Trends.</p>
<figure class="figure"><img decoding="async" class="figure-img img-fluid rounded" src="https://imediacto.com/wp-content/uploads/2021/02/csv-to-json-comparison.png" alt="CSV to JSON conversion comparison" /><figcaption class="figure-caption text-center"><a href="https://trends.google.com/trends/explore?date=all&amp;q=%22csv%20to%20json%22,%22json%20to%20csv%22" target="_blank" rel="nofollow noopener">CSV to JSON conversion comparison</a></figcaption></figure>
<p>CSV and JSON, being the two most popular data formats, it is very useful to have tools to <a href="https://imediacto.com/tools/text-tools/csv-to-json-converter">convert CSV to JSON</a>, or from <strong>JSON to CSV</strong>.</p>
<h2>Conclusion</h2>
<p>You may still be wondering what type of data format is best, but this will depend on your system&#8217;s goals. There is no data format or programming language that is the best for everything, but yes, there may be a better one for a specific need, according to the required requirements.</p>
<p>I would use XML as a technology for integrating systems or applications. I would use CSV to store large volumes of data that need to be concatenated at all times, such as log files, and also for data streaming. Finally, I would use JSON to exchange data between parts of an application, to receive data from a request to an API, as well as to send new data to it.</p>
<div class="notes">
<div class="image"></div>
<div class="message">I hope that this article has been useful for you and that it has introduced you to the world of data formats with XML, CSV and JSON, which are part of every programmer&#8217;s daily life.</div>
</div>
<p><script>hljs.initHighlightingOnLoad()</script></p>
<p>The post <a href="https://imediacto.com/blog/xml-csv-json-data-formats/">XML, CSV, and JSON Data Formats in Practice</a> appeared first on <a href="https://imediacto.com">Free Online Tools - Imediacto</a>.</p>
]]></content:encoded>
					
					<wfw:commentRss>https://imediacto.com/blog/xml-csv-json-data-formats/feed/</wfw:commentRss>
			<slash:comments>0</slash:comments>
		
		
			</item>
		<item>
		<title>Compare Two Lists ~ Free List Comparison Tool</title>
		<link>https://imediacto.com/tools/list-tools/compare-two-lists/</link>
					<comments>https://imediacto.com/tools/list-tools/compare-two-lists/#comments</comments>
		
		<dc:creator><![CDATA[Dante]]></dc:creator>
		<pubDate>Tue, 09 Feb 2021 15:13:34 +0000</pubDate>
				<category><![CDATA[List Tools]]></category>
		<category><![CDATA[Text Tools]]></category>
		<category><![CDATA[Tools]]></category>
		<category><![CDATA[List comparison tool]]></category>
		<guid isPermaLink="false">https://imediacto.com/?p=266</guid>

					<description><![CDATA[<p>This list comparison tool allows you to compare two lists to be able you analyze SET operations (difference, intersection, union, symmetric difference).</p>
<p>The post <a href="https://imediacto.com/tools/list-tools/compare-two-lists/">Compare Two Lists ~ Free List Comparison Tool</a> appeared first on <a href="https://imediacto.com">Free Online Tools - Imediacto</a>.</p>
]]></description>
										<content:encoded><![CDATA[<p><div class="boot">
        <p>This <strong>list comparison tool</strong> allows you to <strong>compare two lists</strong> (arrays) to be able you analyze the <strong>difference between the two lists</strong>.
            The program receives lists of the type string or number and after starting the comparison it is possible to sort the results.</p>

        <!-- Results -->
        <div class="row">
            <div class="col-12 mt-2 mb-2">
                <h2>Inputs</h2>
            </div>
        </div>

        <div class="row">
            <div class="col-md-6 col-12 col-sm-12 mb-3">
                <p class="strong font-topic">Input data structure</p>
                <div class="custom-control custom-radio">
                    <input type="radio" id="sep1" name="items-separation" value="lines" class="custom-control-input"
                        checked>
                    <label class="custom-control-label" for="sep1">From lines</label>
                </div>
                <div class="custom-control custom-radio">
                    <input type="radio" id="sep2" name="items-separation" value="commas" class="custom-control-input">
                    <label class="custom-control-label" for="sep2">Separeted by commas</label>
                </div>
                <div class="custom-control custom-radio">
                    <input type="radio" id="sep3" name="items-separation" value="spaces" class="custom-control-input">
                    <label class="custom-control-label" for="sep3">Separeted by space</label>
                </div>
            </div>
            <div class="col-md-6 col-12 col-sm-12 mb-3">
                <p class="strong font-topic">Input data type</p>
                <div class="custom-control custom-radio">
                    <input type="radio" id="string" name="data-type" value="string" class="custom-control-input"
                        checked>
                    <label class="custom-control-label" for="string">String</label>
                </div>
                <div class="custom-control custom-radio">
                    <input type="radio" id="number" name="data-type" value="number" class="custom-control-input">
                    <label class="custom-control-label" for="number">Number</label>
                </div>
            </div>
        </div>
        <div class="row">
            <div class="col-12 mb-3 hide-on-xs">
                <div class="div-btn mr-1 mr-2" title="Switch view">
                    <i class="fa fa-list" onclick="toggleLines()"> <span>Toggle layout view</span></i>
                </div>
            </div>
            <div class="col-sm-6 mb-3">
                <p class="strong font-topic">List A</p>
                <textarea id="input-a" name="input-a" cols="30" rows="10" placeholder="Insert items for list A"></textarea>
            </div>
            <div class="col-sm-6 mb-3">

                <p class="strong font-topic">List B</p>
                <textarea id="input-b" name="input-a" cols="30" rows="10" placeholder="Insert items for list B"></textarea>
            </div>
        </div>
        <div class="row">
            <div class="col-md-6 col-sm-12 mb-3">
                <p class="strong font-topic">Handle data as</p>
                <div class="custom-control custom-radio">
                    <input type="radio" id="set" name="set-or-list" value="set" class="custom-control-input" checked>
                    <label class="custom-control-label" for="set">As a set (no repeated elements)</label>
                </div>
                <div class="custom-control custom-radio">
                    <input type="radio" id="list" name="set-or-list" value="list" class="custom-control-input">
                    <label class="custom-control-label" for="list">As a list (with repeated elements)</label>
                </div>
            </div>
            <div class="col-md-6 col-sm-12 mb-3">
                <p class="strong font-topic">Output data separetad by</p>
                <div class="custom-control custom-radio">
                    <input type="radio" id="output1" name="items-separation-output" value="lines"
                        class="custom-control-input" checked>
                    <label class="custom-control-label" for="output1">By lines</label>
                </div>
                <div class="custom-control custom-radio">
                    <input type="radio" id="output2" name="items-separation-output" value="commas"
                        class="custom-control-input">
                    <label class="custom-control-label" for="output2">By commas</label>
                </div>
                <div class="custom-control custom-radio">
                    <input type="radio" id="output-" name="items-separation-output" value="spaces"
                        class="custom-control-input">
                    <label class="custom-control-label" for="output-">By space</label>
                </div>
            </div>
        </div>
        <div class="row mb-3">
            <div class="col-sm-12">
                <div class="flex space-between mt-2">
                    <button onclick="applyDiffImproved()" class="btn btn-success mr-2">
                        <i class="fa fa-chevron-right"></i> Compare lists
                    </button>
                    <div class="flex">
                        <!-- TODO :: aplicar button.soft em todos os divs que fazem o papel de botão -->
                        <button class="soft mr-1" onclick="sortAllItems(false)" title="Sort all items asc" aria-label="Sort all items desc">
                            <i class="fa fa-sort-amount-asc"> <span class="hide-on-xs">Sort all asc</span></i>
                        </button>
                        <button class="soft mr-1" onclick="sortAllItems(true)" title="Sort all items asc" aria-label="Sort all items asc">
                            <i class="fa fa-sort-amount-desc"> <span class="hide-on-xs">Sort all desc</span></i>
                        </button>
                    </div>
                </div>
            </div>
        </div>

        <!-- Results -->
        <div class="row">
            <div class="col-12">
                <h2>Results</h2>
            </div>
        </div>
        
        <div class="row">
            
            <!-- Only in A -->
            <div class="col-sm-6 mt-3">
                <div class="flex mb-2">
                    <img decoding="async" src="https://imediacto.com/wp-content/uploads/2021/02/set-a-minus-b.png" class="img-set" alt="Set: A minus B">
                    <p class="strong font-topic" title="A minus B">Only in list A</p>
                </div>
                <pre title="A minus B"><span id="adiffb"><span class="help-text">A diff B</span></span></pre>
                <div class="flex">
                    <button class="soft mr-1" onclick="sortItems('adiffb')" title="Sort items asc" aria-label="Sort items">
                        <i class="fa fa-sort-amount-asc"></i>
                    </button>
                    <button class="soft mr-1" onclick="sortItems('adiffb', true)" title="Sort items desc" aria-label="Sort items">
                        <i class="fa fa-sort-amount-desc"></i>
                    </button>
                    <button class="soft mr-1" onclick="copyToClipboard('adiffb', 'check1')" title="Copy output to clipboard" aria-label="Copy the output A minus B to clipboard">
                        <i class="fa fa-copy"></i>&nbsp;
                    </button>
                    <div id="check1" class="check none"></div>
                </div>
            </div>
            
            <!-- Only in B -->
            <div class="col-sm-6 mt-3">
                <div class="flex mb-2">
                    <img decoding="async" src="https://imediacto.com/wp-content/uploads/2021/02/set-b-minus-a.png" class="img-set" alt="Set: B minus A">
                    <p class="strong font-topic" title="B minus A">Only in list B</p>
                </div>
                <pre title="B minus A"><span id="bdiffa"><span class="help-text">B diff A</span></span></pre>
                <div class="flex">
                    <button class="soft mr-1" onclick="sortItems('bdiffa')" title="Sort items asc" aria-label="Sort items">
                        <i class="fa fa-sort-amount-asc"></i>
                    </button>
                    <button class="soft mr-1" onclick="sortItems('bdiffa', true)" title="Sort items desc" aria-label="Sort items">
                        <i class="fa fa-sort-amount-desc"></i>
                    </button>
                    <button class="soft mr-1" onclick="copyToClipboard('bdiffa', 'check2')" title="Copy output to clipboard" aria-label="Copy the output B minus A to clipboard">
                        <i class="fa fa-copy"></i>&nbsp;
                    </button>
                    <div id="check2" class="check none"></div>
                </div>
            </div>
            
            <!-- A intersection B -->
            <div class="col-sm-6 mt-3">
                <div class="flex mb-2">
                    <img decoding="async" src="https://imediacto.com/wp-content/uploads/2021/02/set-intersection.png" class="img-set" alt="Set: A intersection B">
                    <p class="strong font-topic" title="A intersection B">Common items (A &cap; B)</p>
                </div>
                <pre title="A intersection B"><span id="ainterb"><span class="help-text">Intersection ​​between A and B</span></span></pre>
                <div class="flex">
                    <button class="soft mr-1" onclick="sortItems('ainterb')" title="Sort items asc" aria-label="Sort items">
                        <i class="fa fa-sort-amount-asc"></i>
                    </button>
                    <button class="soft mr-1" onclick="sortItems('ainterb', true)" title="Sort items desc" aria-label="Sort items">
                        <i class="fa fa-sort-amount-desc"></i>
                    </button>
                    <button class="soft mr-1" onclick="copyToClipboard('ainterb', 'check3')" title="Copy output to clipboard" aria-label="Copy the common items to clipboard">
                        <i class="fa fa-copy"></i>&nbsp;
                    </button>
                    <div id="check3" class="check none"></div>
                </div>
            </div>

            <!-- A union B -->
            <div class="col-sm-6 mt-3">
                <div class="flex mb-2">
                    <img decoding="async" src="https://imediacto.com/wp-content/uploads/2021/02/set-union.png" class="img-set" alt="Set: A union B">
                    <p class="strong font-topic" title="A union B">All items (A &cup; B)</p>
                </div>
                <pre title="A union B"><span id="aunionb"><span class="help-text">Union of values ​​between A and B</span></span></pre>
                <div class="flex">
                    <button class="soft mr-1" onclick="sortItems('aunionb')" title="Sort items asc" aria-label="Sort items">
                        <i class="fa fa-sort-amount-asc"></i>
                    </button>
                    <button class="soft mr-1" onclick="sortItems('aunionb', true)" title="Sort items desc" aria-label="Sort items">
                        <i class="fa fa-sort-amount-desc"></i>
                    </button>
                    <button class="soft mr-1" onclick="copyToClipboard('aunionb', 'check4')" title="Copy output to clipboard" aria-label="Copy the union output to clipboard">
                        <i class="fa fa-copy"></i>&nbsp;
                    </button>
                    <div id="check4" class="check none"></div>
                </div>
            </div>
            <!-- Symmetric difference -->
            <div class="col-sm-6 mt-3">
                <div class="flex mb-2">
                    <img decoding="async" src="https://imediacto.com/wp-content/uploads/2021/02/set-symmetric-difference.png" class="img-set" alt="Set: Symmetric diference between A and B">
                    <p class="strong font-topic" title="Symmetric difference">Exclusive items (A &bigtriangleup; B)</p>
                </div>
                <pre title="Symmetric difference"><span id="difference"><span class="help-text">Symmetric difference between A and B</span></span></pre>
                <div class="flex">
                    <button class="soft mr-1" onclick="sortItems('difference')" title="Sort items asc" aria-label="Sort items">
                        <i class="fa fa-sort-amount-asc"></i>
                    </button>
                    <button class="soft mr-1" onclick="sortItems('difference', true)" title="Sort items desc" aria-label="Sort items">
                        <i class="fa fa-sort-amount-desc"></i>
                    </button>
                    <button class="soft mr-1" onclick="copyToClipboard('difference', 'check5')" title="Copy output to clipboard" aria-label="Copy the symetric difference between A and B to clipboard">
                        <i class="fa fa-copy"></i>&nbsp;
                    </button>
                    <div id="check5" class="check none"></div>
                </div>
            </div>
        </div>
        <hr>
        <section class="tips">
        <h2>Tips for Better Results</h2>
            <ul>
                <li>Paste clean text without extra spaces.</li>
                <li>Use “set” mode to ignore duplicates.</li>
                <li>Use “list” mode to include repeated items.</li>
            </ul>
        </section>
        <hr>
        <h2>How does the Compare Two Lists tool work?</h2>
        <p>It will function normally according to the rules of the sets, in Mathematics. However, in this tool, you can also choose the list option, so that it is possible to work with repeated values. The following operations are performed:</p>

        <div class="flex mt-3">
            <img decoding="async" src="https://imediacto.com/wp-content/uploads/2021/02/set-a-minus-b.png" class="img-set" alt="Set: A minus B"><h3 class="mb-0 mt-0 pb-0">A minus B</h3>
        </div>
        <p>Returns the values ​​that are present only in list A.</p>

        <div class="flex mt-3">
            <img decoding="async" src="https://imediacto.com/wp-content/uploads/2021/02/set-b-minus-a.png" class="img-set" alt="Set: B minus A"><h3 class="mb-0 mt-0 pb-0">B minus A</h3>
        </div>
        <p>Returns the values ​​that are present only in list B.</p>

        <div class="flex mt-3">
            <img decoding="async" src="https://imediacto.com/wp-content/uploads/2021/02/set-intersection.png" class="img-set" alt="Set: A intersection B"><h3 class="mb-0 mt-0 pb-0">A intersection B</h3>
        </div>
        <p>They are represented by the values ​​that occur simultaneously in the two lists.</p>

        <div class="flex mt-3">
            <img decoding="async" src="https://imediacto.com/wp-content/uploads/2021/02/set-union.png" class="img-set" alt="Set: A union B"><h3 class="mb-0 mt-0 pb-0">A union B</h3>
        </div>
        <p>They are represented by all the values ​​present in both lists.</p>

        <div class="flex mt-3">
            <img decoding="async" src="https://imediacto.com/wp-content/uploads/2021/02/set-symmetric-difference.png" class="img-set" alt="Set: Symmetric diference between A and B"><h3 class="mb-0 mt-0 pb-0">Symmetric difference</h3>
        </div>
        <p>The symmetric difference of two sets is the set of elements that are in one of the sets, but not at its intersection.</p>

        <h2>Important note</h2>

        <p>There is no limitation on the maximum number of rows allowed in a list, however, if you put in too large a volume of data, the browser may slow down or even crash for a moment.</p>
        
        <hr>
        <!-- FAQ sem JS -->
        <h2 class="mt-4 mb-3">FAQ about this Comparison List Tool</h2>

        <div class="faq-list">
            <details>
                <summary>Can I compare lists with numbers?</summary>
                <div class="faq-content">
                    Yes. Just switch the “Data Type” option to <strong>Number</strong> before clicking <em>Compare Lists</em>.
                </div>
            </details>

            <details>
                <summary>What is the maximum list size?</summary>
                <div class="faq-content">
                    There is no fixed limit. However, very large lists (thousands of lines) may slow down your browser temporarily.
                </div>
            </details>

            <details>
                <summary>Does this tool store my data?</summary>
                <div class="faq-content">
                    No. All processing happens locally in your browser — your data never leaves your device.
                </div>
            </details>

            <details>
                <summary>Can I find duplicate items between two lists?</summary>
                <div class="faq-content">
                    Yes. Use the <strong>Common items (A ∩ B)</strong> section to see all items that appear in both lists — these are your duplicates.
                </div>
            </details>

            <details>
                <summary>Is the comparison case sensitive?</summary>
                <div class="faq-content">
                    Yes. The comparison is <strong>case sensitive</strong>, meaning “Apple” and “apple” are treated as different items.
                </div>
            </details>

            <details>
                <summary>What is the difference between Union and Symmetric Difference?</summary>
                <div class="faq-content">
                    <strong>Union (A ∪ B)</strong> shows all unique items from both lists combined.  
                    <strong>Symmetric Difference (A △ B)</strong> shows items that appear in either list, but <em>not</em> in both — the unique items from each list.
                </div>
            </details>
        </div>

        <!-- JSON-LD FAQ schema for SEO -->
        <script type="application/ld+json">
        {
        "@context": "https://schema.org",
        "@type": "FAQPage",
        "mainEntity": [
                {
                "@type": "Question",
                "name": "Can I compare lists with numbers?",
                "acceptedAnswer": {
                    "@type": "Answer",
                    "text": "Yes. Just switch the Data Type option to Number before clicking Compare Lists."
                }
                },
                {
                "@type": "Question",
                "name": "What is the maximum list size?",
                "acceptedAnswer": {
                    "@type": "Answer",
                    "text": "There is no fixed limit. However, very large lists may slow down your browser temporarily."
                }
                },
                {
                "@type": "Question",
                "name": "Does this tool store my data?",
                "acceptedAnswer": {
                    "@type": "Answer",
                    "text": "No. All processing happens locally in your browser — your data never leaves your device."
                }
                },
                {
                "@type": "Question",
                "name": "Can I find duplicate items between two lists?",
                "acceptedAnswer": {
                    "@type": "Answer",
                    "text": "Yes. Use the In Both Lists (A ∩ B) section to see all items that appear in both lists — these are your duplicates."
                }
                },
                {
                "@type": "Question",
                "name": "Is the comparison case sensitive?",
                "acceptedAnswer": {
                    "@type": "Answer",
                    "text": "Yes. The comparison is case sensitive, meaning 'Apple' and 'apple' are considered different items."
                }
                },
                {
                "@type": "Question",
                "name": "What is the difference between Union and Symmetric Difference?",
                "acceptedAnswer": {
                    "@type": "Answer",
                    "text": "Union (A ∪ B) shows all unique items from both lists combined, while Symmetric Difference (A △ B) shows items that appear in either list but not in both."
                }
                }
            ]
        }
        </script>
        
        <div class="notes">
            <div class="image"></div>
            <div class="message">
                <p>
                    List comparison is a recurring task among professional programmers and students.
                    If you want some new feature for this <strong>Compare Two Lists</strong> tool, let me know in the comments area.
                    Also, tell me if you found some bug, that I can fix it as soon as possible.
                </p>
                <p>
                    You can learn about how this online list tool works or contribute improving the it
                    by programming some new feature or fixing bugs. For that, go to Github on <a
                        href="https://github.com/dantovsky/Imediacto-Online-Tool-Set/tree/master/tools/008-compare-two-lists"
                        target="_blank">Github >> Compare Two Lists</a> and make a pull request. This will be great!
                </p>
            </div>
        </div>
    </div>

    <script>
        let separatorOutput = '\n';

        // Improved
        function applyDiffImproved() {

            const itemsSeparationsInput = document.querySelector('input[name="items-separation"]:checked').value
            const setOrList = document.querySelector('input[name="set-or-list"]:checked').value
            const itemsSeparationsOutput = document.querySelector('input[name="items-separation-output"]:checked').value

            // Input sepearator
            let separatorInput = '\n';
            if (itemsSeparationsInput == 'lines') {
                separatorInput = '\n';
            } else if (itemsSeparationsInput == 'commas') {
                separatorInput = ',';
            } else if (itemsSeparationsInput == 'spaces') {
                separatorInput = ' ';
            }

            // Output sepearator
            if (itemsSeparationsOutput == 'lines') {
                separatorOutput = '\n';
            } else if (itemsSeparationsOutput == 'commas') {
                separatorOutput = ', ';
            } else if (itemsSeparationsOutput == 'spaces') {
                separatorOutput = ' ';
            }

            // Set or list
            const isSet = setOrList === 'set' ? true : false

            // Get items on input textareas
            let inputA = document.getElementById('input-a').value.split(separatorInput)
            let inputB = document.getElementById('input-b').value.split(separatorInput)

            if (separatorInput == '\n') {
                inputA = inputA.filter(item => item != '')
                inputB = inputB.filter(item => item != '')
            }

            if (separatorInput == '\n' || separatorInput == ',') {
                inputA = inputA.map(item => item.trim())
                inputB = inputB.map(item => item.trim())
            } else {
                // Remove empty elements
                inputA = inputA.filter(item => item != '')
                inputB = inputB.filter(item => item != '')
            }

            aDiffB = []
            bDiffA = []
            aInterB = []

            // Passing through arrayA :: get A diff B and A inter B
            for (item in inputA) {
                if (!inputB.includes(inputA[item])) {
                    aDiffB.push(inputA[item])
                } else {
                    aInterB.push(inputA[item])
                }
            }

            // Passing through arrayB :: get B diff A
            bDiffA = inputB.filter(item => !inputA.includes(item))

            // Writing results
            if (isSet) {
                document.getElementById('adiffb').innerHTML = [...new Set(aDiffB)].join(separatorOutput)
                document.getElementById('bdiffa').innerHTML = [...new Set(bDiffA)].join(separatorOutput)
                document.getElementById('ainterb').innerHTML = [...new Set(aInterB)].join(separatorOutput)
                document.getElementById('aunionb').innerHTML = [...new Set(inputA.concat(inputB))].join(separatorOutput)
                document.getElementById('difference').innerHTML = [...new Set(aDiffB.concat(bDiffA))].join(separatorOutput)
            } else {
                document.getElementById('adiffb').innerHTML = aDiffB.join(separatorOutput)
                document.getElementById('bdiffa').innerHTML = bDiffA.join(separatorOutput)
                document.getElementById('ainterb').innerHTML = aInterB.join(separatorOutput)
                document.getElementById('aunionb').innerHTML = inputA.concat(inputB).join(separatorOutput)
                document.getElementById('difference').innerHTML = aDiffB.concat(bDiffA).join(separatorOutput)
            }
        }

        function toggleLines() {
            const elems = document.querySelectorAll('.row > div')
            elems.forEach(elem => {
                elem.classList.contains('col-sm-12') ? elem.classList.remove('col-sm-12') : elem.classList.add('col-sm-12')
            })
        }

        function sortItems(id, isDesc = false) {

            const dataType = document.querySelector('input[name="data-type"]:checked').value
            const element = document.getElementById(id)
            let content = element.innerText.split(separatorOutput)

            if (dataType === 'string') {
                content.sort()
                if (isDesc) {
                    content = content.reverse()
                }
            } else if (dataType === 'number') {
                isDesc ? content.sort((a, b) => b - a) : content.sort((a, b) => a - b)
            }

            element.innerHTML = content.join(separatorOutput)
        }
        
        function sortAllItems(isDesc = false) {
            const operations = ['adiffb','bdiffa','ainterb','aunionb','difference']
            operations.forEach(operation => {
                sortItems(operation, isDesc)
            })
        }

        // https://www.w3resource.com/javascript-exercises/javascript-array-exercise-23.php
        // https://stackoverflow.com/questions/9229645/remove-duplicate-values-from-js-array
        // https://www.30secondsofcode.org/blog/s/copy-text-to-clipboard-with-javascript
        // https://fontawesome.com/v4.7.0/icons/

    </script></p>
<p>The post <a href="https://imediacto.com/tools/list-tools/compare-two-lists/">Compare Two Lists ~ Free List Comparison Tool</a> appeared first on <a href="https://imediacto.com">Free Online Tools - Imediacto</a>.</p>
]]></content:encoded>
					
					<wfw:commentRss>https://imediacto.com/tools/list-tools/compare-two-lists/feed/</wfw:commentRss>
			<slash:comments>6</slash:comments>
		
		
			</item>
		<item>
		<title>Bulk Image Resizer and Compressor</title>
		<link>https://imediacto.com/tools/image-tools/bulk-image-resizer-and-compressor/</link>
					<comments>https://imediacto.com/tools/image-tools/bulk-image-resizer-and-compressor/#respond</comments>
		
		<dc:creator><![CDATA[Dante]]></dc:creator>
		<pubDate>Mon, 05 Oct 2020 17:03:40 +0000</pubDate>
				<category><![CDATA[Image Tools]]></category>
		<category><![CDATA[Tools]]></category>
		<guid isPermaLink="false">https://imediacto.com/?p=249</guid>

					<description><![CDATA[<p>It's an Image Online Tool that helps you to optimize images and photos, such as resizing, compressing, and converting. It's good for SEO optimization.</p>
<p>The post <a href="https://imediacto.com/tools/image-tools/bulk-image-resizer-and-compressor/">Bulk Image Resizer and Compressor</a> appeared first on <a href="https://imediacto.com">Free Online Tools - Imediacto</a>.</p>
]]></description>
										<content:encoded><![CDATA[<p><div class="boot">
        <h1>Bulk Image Resizer and Compressor</h1>
        <div class="boots">
            <h2>Free Online Batch Image Resizer and Compressor</h2>
            <p>This application allows you to resize and compress a single image or multiple images in a batch mode,
                preserving the
                aspect ratio of the images. It's very useful if you want to reduce a photo to a smaller size.</p>

            <div class="row">
                <div class="col-12">
                    <h3>Select your images (.jpg, .png)</h3>
                    <div class="custom-file mb-2">
                        <input type="file" class="custom-file-input" id="file" accept="image/jpeg,image/png" multiple>
                        <label id="holder" class="input-drag-drop" for="file">
                            <div id="file-name" class="file-name text-truncate">
                                Drag & Drop your images here
                            </div>
                            <div class="text-browse"><i class="fa fa-search"></i>
                                <span class="hidden-680-down">Browse</span>
                            </div>
                        </label>
                    </div>
                </div>
                <div class="col-md-6 col-sm-12 mb-2">
                    <h3>Type the new width</h3>
                    <div class="form-group">
                        <input id="new-width" class="form-control mb-2 mr-sm-2" type="number" placeholder="New width"
                            min="10" max="8000">
                        <!-- <div id="error-msg-new-width" class="invalid-feedback" style="margin-top: -19px;"></div> -->
                    </div>
                </div>
                <div class="col-md-6 col-sm-12 mb-2">
                    <h3>Image quality (<span id="quality-selected">92</span>%)</h3>
                    <div class="form-group">
                        <!-- class="form-control-range" -->
                        <input type="range" id="quality" class="custom-range mt-3" min="0" max="100" value="92">
                        <!-- <input type="range" class="custom-range" min="0" max="100" id="quality" value="92"> -->
                    </div>
                </div>
            </div>
            <div class="row">
                <div class="col-12">
                    <p id="num-items"></p>
                    <div id="list-files" class="mb-3"></div>

                    <div class="custom-control custom-checkbox mb-2">
                        <input type="checkbox" class="custom-control-input" id="zip-output">
                        <label class="custom-control-label" for="zip-output">Output images in a zip file</label>
                    </div>
                </div>
            </div>
            <!-- <div class="row">
                <div class="col-12">
                    <div class="form-check mb-2">
                        <div class="custom-control custom-checkbox">
                            <input type="checkbox" class="custom-control-input" id="zip-output">
                            <label class="custom-control-label" for="zip-output">Wrap the words in quotes</label>
                        </div>
                    </div>
                </div>
            </div> -->
        </div>
        <div class="row">
            <div class="col-12 mb-3">
                <!-- <button class="btn btn-success" onclick="compress(event);" disabled>Resize images</button> -->
                <button class="btn btn-success mb-2" onclick="compress(event);" disabled
                    aria-label="Button to convert CSV to JSON">
                    <i class="fa fa-chevron-right"></i>
                    Resize images
                </button>
            </div>
        </div>
        <div class="row">
            <div class="col-12">
                <div id="message-error"></div>
            </div>
        </div>

        <hr />

        <h3>For what or for whom is this app useful?</h3>
        <p>The Bulk Image Resizer is useful for photographer, designers or SEO experts. One of the jobs of SEO
            optimization is to reduce and compress the size of the images. This app will help you to reduce the size
            in
            pixels and choose a level quality to compress it.</p>
        <p>
            Alternatively, you can resize to a new dimension and maintain 92% of the quality compression (standard
            compression used when resizing) and then use another tool to reduce the size in weight (kB or MB) of the
            images, such as <a href="https://tinypng.com/" target="_blank">tinypng.com</a>.</p>
        <p>The main benefits of this online tool are:
        <ul>
            <li>Avoid installing a tool on your machine.</li>
            <li>Apply the batch resizer (not just one image at a time).</li>
            <li>Get lighter images for a more performing website.</li>
        </ul>
        </p>
    </div>
    <script>
        // referências
        const holder = document.getElementById('holder');
        const fileInput = document.getElementById('file');
        const btn = document.querySelector('button.btn-success');

        // injeta a barra de progresso logo abaixo do botão
        const progContainer = document.createElement('div');
        progContainer.id = 'progress-container';
        progContainer.style.display = 'none';
        progContainer.innerHTML = `
            <progress id="progress-bar" value="0" max="0"></progress>
            <p id="progress-text">0/0</p>
        `;
        btn.parentNode.insertBefore(progContainer, btn.nextSibling);

        const progressBar = document.getElementById('progress-bar');
        const progressText = document.getElementById('progress-text');

        // Previna comportamento padrão nos eventos de drag
        ['dragenter', 'dragover', 'dragleave', 'drop'].forEach(evt => {
            holder.addEventListener(evt, e => {
                e.preventDefault(); e.stopPropagation();
            });
        });

        // Destaca ao arrastar por cima
        ['dragenter', 'dragover'].forEach(evt => {
            holder.addEventListener(evt, () => holder.classList.add('input-drop'));
        });

        // Remove destaque
        ['dragleave', 'drop'].forEach(evt => {
            holder.addEventListener(evt, () => holder.classList.remove('input-drop'));
        });

        // Trata o drop – popula o input e dispara change
        holder.addEventListener('drop', e => {
            if (!e.dataTransfer.files.length) return;
            const dt = new DataTransfer();
            Array.from(e.dataTransfer.files).forEach(f => dt.items.add(f));
            fileInput.files = dt.files;
            fileInput.dispatchEvent(new Event('change'));
        });

        // Placeholder e mensagem de erro
        const newWidth = document.getElementById('new-width');
        newWidth.setAttribute('placeholder', `Min ${newWidth.min} e max ${newWidth.max}`);
        document.getElementById('message-error').innerText =
            `Type a valid width (min ${newWidth.min} e max ${newWidth.max}).`;
        if (localStorage.bulkImageResizerWidth)
            newWidth.value = localStorage.bulkImageResizerWidth;

        // Atualiza label da qualidade
        ['mousemove', 'change'].forEach(evt =>
            document.getElementById('quality').addEventListener(evt, e =>
                document.getElementById('quality-selected').innerText = e.target.value
            )
        );

        // Mostra lista de ficheiros e ativa botão
        fileInput.addEventListener('change', e => {
            const listFiles = document.getElementById('list-files');
            const numItems = document.getElementById('num-items');
            const files = e.target.files;
            let totalSize = 0;
            listFiles.innerHTML = '';
            if (files.length) {
                btn.disabled = false;
                listFiles.classList.add('display-block');
                Array.from(files).forEach(f => {
                    const p = document.createElement('p');
                    p.innerText = f.name;
                    listFiles.appendChild(p);
                    totalSize += f.size;
                });
                numItems.classList.add('display-block');
                numItems.innerHTML =
                    `There ${files.length === 1 ? 'is' : 'are'} <strong>${files.length}</strong>` +
                    ` image${files.length === 1 ? '' : 's'} to resize, ` +
                    `total <strong>${(totalSize / 1000).toFixed(2)} kB</strong>.`;
            } else {
                btn.disabled = true;
                numItems.classList.remove('display-block');
                listFiles.classList.remove('display-block');
            }
            // esconde progress se voltar a escolher
            progContainer.style.display = 'none';
        });

        // Função principal
        function compress() {
            const width = Number(newWidth.value);
            const min = Number(newWidth.min);
            const max = Number(newWidth.max);
            const files = Array.from(fileInput.files);
            const quality = Number(document.getElementById('quality').value);
            const toZip = document.getElementById('zip-output').checked;

            if (width < min || width > max) {
                const msg = document.getElementById('message-error');
                msg.classList.add('display-block');
                setTimeout(() => msg.classList.remove('display-block'), 5000);
                return;
            }

            // preenche progress bar
            progressBar.max = files.length;
            progressBar.value = 0;
            progressText.innerText = `0/${files.length}`;
            progContainer.style.display = 'block';

            // instância Zip se necessário
            const zip = toZip ? new JSZip() : null;

            files.forEach(file => {
                const reader = new FileReader();
                reader.readAsDataURL(file);
                reader.onload = ev => {
                    const img = new Image();
                    img.src = ev.target.result;
                    img.onload = () => {
                        // desenha canvas
                        const canvas = document.createElement('canvas');
                        canvas.width = width;
                        canvas.height = width * (img.height / img.width);
                        const ctx = canvas.getContext('2d');
                        ctx.drawImage(img, 0, 0, canvas.width, canvas.height);

                        // função interna para tratar blob comum
                        const handleBlob = blob => {
                            if (toZip) {
                                zip.file(file.name, blob);
                            } else {
                                const link = document.createElement('a');
                                link.href = URL.createObjectURL(blob);
                                link.download = file.name;
                                document.body.appendChild(link);
                                link.click();
                                link.remove();
                                URL.revokeObjectURL(link.href);
                            }

                            // actualiza progresso
                            progressBar.value++;
                            progressText.innerText = `${progressBar.value}/${files.length}`;

                            // se terminou e é zip, gera e faz download
                            if (progressBar.value === files.length && toZip) {
                                zip.generateAsync({ type: 'blob' }).then(zipBlob => {
                                    const zipLink = document.createElement('a');
                                    zipLink.href = URL.createObjectURL(zipBlob);
                                    zipLink.download = 'crompressed-images.zip';
                                    document.body.appendChild(zipLink);
                                    zipLink.click();
                                    zipLink.remove();
                                    URL.revokeObjectURL(zipLink.href);
                                    setTimeout(() => progContainer.style.display = 'none', 2000);
                                });
                            }
                            else if (progressBar.value === files.length) {
                                // esconde progress após 2s (sem zip)
                                setTimeout(() => progContainer.style.display = 'none', 2000);
                            }
                        };

                        // branch PNG: usa UPNG para quantizar
                        if (file.type === 'image/png') {
                            const imgData = ctx.getImageData(0, 0, canvas.width, canvas.height);
                            const buf = imgData.data.buffer;
                            const maxColors = Math.max(2, Math.round(quality * 2.56));
                            const pngBuf = UPNG.encode([buf], canvas.width, canvas.height, maxColors);
                            const blob = new Blob([pngBuf], { type: 'image/png' });
                            handleBlob(blob);
                        }
                        // branch outros formatos (JPEG, WebP…)
                        else {
                            canvas.toBlob(blob => {
                                handleBlob(blob);
                            }, file.type, quality / 100);
                        }

                        // guarda largura
                        localStorage.bulkImageResizerWidth = width;
                    };
                };
            });
        }
    </script></p>
<p>The post <a href="https://imediacto.com/tools/image-tools/bulk-image-resizer-and-compressor/">Bulk Image Resizer and Compressor</a> appeared first on <a href="https://imediacto.com">Free Online Tools - Imediacto</a>.</p>
]]></content:encoded>
					
					<wfw:commentRss>https://imediacto.com/tools/image-tools/bulk-image-resizer-and-compressor/feed/</wfw:commentRss>
			<slash:comments>0</slash:comments>
		
		
			</item>
		<item>
		<title>Letter Case Types in Programming</title>
		<link>https://imediacto.com/blog/list-of-letter-case-types-in-programming/</link>
					<comments>https://imediacto.com/blog/list-of-letter-case-types-in-programming/#comments</comments>
		
		<dc:creator><![CDATA[Dante]]></dc:creator>
		<pubDate>Sat, 20 Jun 2020 23:05:33 +0000</pubDate>
				<category><![CDATA[Tech Blog]]></category>
		<guid isPermaLink="false">https://imediacto.com/?p=199</guid>

					<description><![CDATA[<p>In this article I will list and exemplify the most common types of text case / letter case that we can find in  different types of text or in conventions and rules of use, as in programming.</p>
<p>The post <a href="https://imediacto.com/blog/list-of-letter-case-types-in-programming/">Letter Case Types in Programming</a> appeared first on <a href="https://imediacto.com">Free Online Tools - Imediacto</a>.</p>
]]></description>
										<content:encoded><![CDATA[<blockquote><p>In this article I will list and exemplify the most common types of text case / letter case that we can find in different types of text or in conventions and rules of use, as in programming.</p></blockquote>
<p>Some of the <strong>letter case types</strong> are:</p>
<table>
<thead>
<tr>
<th>Letter Case Name</th>
<th>Short Example</th>
</tr>
</thead>
<tbody>
<tr>
<td>Uppercase</td>
<td>TEXT IN UPPERCASE</td>
</tr>
<tr>
<td>Lowercase</td>
<td>text in lowercase</td>
</tr>
<tr>
<td>Sentence case</td>
<td>Sentence case</td>
</tr>
<tr>
<td>Capital letter</td>
<td>Capital Letter</td>
</tr>
<tr>
<td>Title case</td>
<td>This is a Title Case</td>
</tr>
<tr>
<td>Camel case</td>
<td>camelCaseText</td>
</tr>
<tr>
<td>Upper camel case</td>
<td>UpperCamelCaseText</td>
</tr>
<tr>
<td>Pascal case</td>
<td>PascalCaseText</td>
</tr>
<tr>
<td>Kebab case</td>
<td>kebab-case-text</td>
</tr>
<tr>
<td>Snake case</td>
<td>snake_case</td>
</tr>
</tbody>
</table>
<p>Well, the examples above already explain by themselves. Next, I will make a short description about each one.</p>
<h2>UPPERCASE</h2>
<p>Text format when it is all written, that is, all letters of all words, in capital letters.</p>
<h2>lowercase</h2>
<p>Text format when it is all written in lowercase letters (all letters of all words).</p>
<h2>Sentence case</h2>
<p>For each sentence, only the first letter is capitalized (in uppercase). The separators for each sentence are usually:</p>
<ul>
<li>Consecutive point or points (.)</li>
<li>Exclamation (!)</li>
<li>Interrogation (?)</li>
</ul>
<p><span class="ex">Example:</span> &#8220;Today I started to study Javascript. I&#8217;m really enjoying it!&#8221;</p>
<h2>Capital Letters</h2>
<p>This mode capitalizes the first letter of each word.<br />
<span class="ex">Example:</span> &#8220;Today I Started Learning Javascript And Developed A Text Case Converter.&#8221;</p>
<h2>Title Case</h2>
<p>This mode will capitalize the first letter of some words in the text, following the grammatical rule of a particular country. In many countries, for example, we do not capitalize on defined and indefinite pronouns when they are found after the second word of the text, among other rules.<br />
<span class="ex">Example:</span> “We Build a New Program”.</p>
<h2>camelCase</h2>
<p>The camel case will capitalize all the first letters from the second word in the text and will remove all spaces between words.<br />
<span class="ex">Example:</span> “theTextConversion”.</p>
<p>In the camel case, we can also divide in some particular cases:</p>
<ul>
<li>lowerCamelCase (when we start the first word with a lowercase), this model is widely used in programming for variable names.</li>
<li>UpperCamelCase (when we start the first word with a capital letter), this model is widely used in programming for class names.</li>
</ul>
<h2>PascalCase</h2>
<p>The pascal case is the same as “Upper Camel Case”, that is, all the first letters of each word are capitalized.</p>
<h2>kebab-case</h2>
<p>In this text model, the letters are in lowercase and all spaces are replaced by a hyphen (-). In the codes of the CSS style sheets, it is written in this format to separate the terms.<br />
<span class="ex">Example:</span> “i-like-eating-kebab”.</p>
<p>There is a very wide variety of synonyms for the kebab case:</p>
<ul>
<li>Kebab case</li>
<li>Caterpillar case</li>
<li>Dash case</li>
<li>Hyphen case</li>
<li>Lisp case</li>
<li>Spinal case</li>
<li>CSS case</li>
<li>Hiphenated</li>
</ul>
<h2>snake_case</h2>
<p>In this model we have all lowercase letters and spaces are replaced by the underscore (_). We can also have the version “snake case all caps” where the letters are in capital letters.<br />
<span class="ex">Example:</span> “i_like_pizza”. This model is widely used in the Python language.</p>
<p>Example (all caps): “I_LIKE_PIZZA”. This model is widely used to name constants in “C-like” languages ​​(families of languages ​​that are based on C).</p>
<h2>Conclusion</h2>
<p>There are many types of letter cases and there are a multitude of rules to be able to use them, depending on the area of expertise such as Mathematics, Programming, Science, etc.</p>
<p>We often need to convert from one format to another, and when we have a very large text it is not very practical to convert them manually. For that we can use a <a href="https://imediacto.com/tools/text-tools/case-converter">case converter</a> to do this job very easily.</p>
<div class="notes">
<div class="image"></div>
<div class="message">I hope this article has been helpful to you. Good conversions! =)</div>
</div>
<p>The post <a href="https://imediacto.com/blog/list-of-letter-case-types-in-programming/">Letter Case Types in Programming</a> appeared first on <a href="https://imediacto.com">Free Online Tools - Imediacto</a>.</p>
]]></content:encoded>
					
					<wfw:commentRss>https://imediacto.com/blog/list-of-letter-case-types-in-programming/feed/</wfw:commentRss>
			<slash:comments>2</slash:comments>
		
		
			</item>
	</channel>
</rss>
