Generate RFC-compliant UUID v1, v3, v4, v5, v6, v7 and v8 — one at a time or in bulk — plus validate, format, export and manage them entirely in your browser.
This is a formatted preview only — nothing here is sent over the network; it simply shows how your generated UUIDs would look inside a JSON body, a cURL command, or a GraphQL query/response.
Keyboard shortcuts: Ctrl+Enter generate · Ctrl+C copy all · Ctrl+D download.
Name-based UUIDs are deterministic: the same namespace + name always produces the same UUID — useful for stable IDs derived from a URL, email, username, domain or filename.
History and favorites are saved only in this browser (localStorage) — never uploaded anywhere. Recent downloads are also logged here.
The original UUID Generator did exactly one job: it produced random version-4 UUIDs, one at a time or in a small bulk batch, with an uppercase toggle and a hyphen toggle. That covered the most common developer need — a quick, disposable unique ID for a test record or a placeholder key — but real projects lean on far more than random IDs alone. Databases want sortable, time-ordered keys; distributed systems and content pipelines need deterministic IDs derived from a name or URL so the same input always produces the same identifier; and anyone debugging an existing system needs to paste in a UUID and understand exactly what it is. The Professional UUID Generator keeps the one-click simplicity of the original tool and builds a complete developer workbench around it: seven UUID versions (v1, v3, v4, v5, v6, v7, v8), a full validator that decodes version, variant and embedded timestamp and points to the exact character that breaks an invalid UUID, deterministic name-based generation from four standard namespaces or your own, rich formatting and export options, session statistics, a local history with favorites and a QR code exporter — all generated locally in your browser, with nothing ever uploaded to a server.
Every version follows its governing specification precisely. UUID v4 is generated with the browser's cryptographically secure crypto.getRandomValues (via crypto.randomUUID() where available) — 122 random bits with the version and variant nibbles set per RFC 4122. UUID v1 encodes a 60-bit Gregorian timestamp (100-nanosecond intervals since 15 October 1582) together with a random clock sequence and a randomly generated, multicast-flagged node identifier — the RFC's explicitly sanctioned fallback for the many situations, like a browser, where a real IEEE 802 MAC address simply isn't available. UUID v6 takes the same time-based fields as v1 and reorders them most-significant-bits-first, so v6 identifiers sort chronologically as plain strings — useful as primary keys in databases that benefit from sequential inserts. UUID v7, the newest widely adopted format from RFC 9562, embeds a 48-bit Unix millisecond timestamp followed by cryptographically random bits, giving you a UUID that is both sortable and easy to reason about, since the timestamp is a familiar Unix epoch rather than the 1582 Gregorian count. UUID v8 is the specification's explicitly custom, vendor-defined layout; this tool's v8 seeds the identifier with the current timestamp for uniqueness while filling the remainder with secure random bits, correctly tagged with version 8 and the RFC 4122/9562 variant bits. UUID v3 and v5 are name-based: they hash a namespace UUID together with a name you provide — using MD5 for v3 and SHA-1 for v5 — so the same namespace and name deterministically produce the same UUID every time, which is exactly what you want for de-duplicating records derived from a URL, e-mail address or filename. Every generator was checked against the official RFC 4122 test vectors (the DNS-namespace v3 and v5 UUIDs for "www.example.com") and produces bit-for-bit identical output.
Switch to the Validate tab and paste any UUID — with or without hyphens, braces, parentheses or quotes — to see it decoded. A valid UUID reports its version, its variant (RFC 4122/9562, the legacy NCS layout, the Microsoft GUID layout, or a reserved variant), and — for v1, v6 and v7, which embed a timestamp — the exact date and time the UUID was created, decoded straight from its bits. An invalid UUID gets a clear diagnosis instead of a generic error: the tool walks the string character by character against the expected 8-4-4-4-12 hyphenated pattern and highlights the exact position and reason it fails, whether that's a misplaced hyphen, a non-hexadecimal character, or the wrong overall length.
The Generate tab's formatting row controls how UUIDs are shown and combined. Per-value styles wrap each UUID in curly braces, parentheses or quotes — the exact syntax many languages and config files expect around a GUID literal — or leave it plain. Whole-batch container styles turn the entire list into a single JSON array, a CSV column, a ready-to-run SQL INSERT statement, or an XML document. Independently, you can flip every UUID to uppercase or lowercase, toggle hyphens on or off, add a custom prefix or suffix to every value, choose a custom separator between entries, and switch on line numbers for a numbered list.
Every batch reports how many UUIDs are in it, how many are unique, how many duplicates were found (vanishingly rare for random v4s, but a genuine possibility with deterministic name-based UUIDs if you generate the same name twice), the total character count of the current output, how long generation took, and how many UUIDs were produced per second — handy for confirming the tool comfortably handles a 1,000-UUID batch in a fraction of a second. A running total across your whole session, plus a live breakdown of how many UUIDs of each version you've generated, sits alongside the per-batch numbers.
A prefix and suffix let you turn a bare UUID into an identifier that matches your naming convention (user_<uuid>, <uuid>_v1), a custom separator replaces the default newline when you need comma- or tab-joined output, and line numbers add an index to every entry for quick reference in a long batch. The Developer / API preview panel formats your current batch as a JSON response body, a REST cURL example, or a GraphQL mutation and response — a copyable illustration of how the UUIDs would look inside a real API payload. Nothing here makes a network call; it is a local text preview only.
Beyond the on-screen formatting, dedicated export buttons download the current batch as a plain TXT file, a CSV with index/uuid/version columns, a JSON array of objects, an XML document, or a ready-to-run SQL INSERT statement — plus one-click clipboard copy of the whole batch in its current on-screen format. A QR code button encodes a single UUID, or up to 25 UUIDs at once, into a scannable code you can save or print.
Switch to the History & Favorites tab to see every UUID you've generated this session (and previous sessions, since it's saved locally), searchable, filterable by version, and filterable to favourites only. Star any UUID to bookmark it, bulk-copy or bulk-download whatever is currently shown after filtering, bulk-delete just the filtered subset, or clear everything in one step. A recent-downloads log tracks every file you've exported, with a timestamp, so you can see at a glance what you generated and when.
Every UUID — random or deterministic — is generated entirely inside your browser using the Web Crypto API and hand-written hash routines; nothing you type or generate is ever uploaded or sent to a server. History, favourites and your format preferences live only in this browser's local storage, under your control, and a "clear all history" button wipes them instantly. The tool keeps working with no internet connection once the page has loaded (aside from the optional QR code library and the one-time page load itself), and there is no account, no signup and no tracking of your generated values.
The Professional UUID Generator is a free, entirely browser-based tool for generating and inspecting Universally Unique Identifiers — the 128-bit values used everywhere in modern software to name database rows, session tokens, distributed-system messages, file identifiers and API resources without ever needing a central authority to hand out the next number. What started life as a single-purpose "give me a random UUID" button has grown into a complete workbench that covers every UUID version in active use, a full validator, deterministic name-based generation, rich formatting and export, and a local history — while keeping the original tool's core promise: everything happens on your device, instantly, with nothing ever uploaded anywhere.
At the heart of the tool are seven UUID generators, each implemented to match its governing specification exactly rather than approximated. Version 4, the workhorse of modern software, is 122 bits of cryptographically secure randomness drawn from the browser's Web Crypto API — the same source used for encryption keys — with the version and variant bits set so any RFC-aware system recognises it correctly. Version 1 takes the opposite approach: instead of pure randomness it encodes a 60-bit timestamp counted in 100-nanosecond intervals since 15 October 1582 (the date the Gregorian calendar was adopted, chosen by the original 1980s DCE specification), combined with a random clock sequence and a node identifier. Real UUID v1 implementations on a physical machine use that machine's network card address as the node ID; a browser has no such thing to offer, so this tool does exactly what RFC 4122 explicitly permits in that situation — generates a random node ID and sets its multicast bit, which tells any reader that the node portion is not a real hardware address. Version 6 takes those same time-based fields and reorders them so the most significant bits come first, which means — unlike v1 — a batch of v6 UUIDs sorts correctly as plain text strings, a property database engineers care about deeply because sequential, sorted primary keys insert far more efficiently than randomly ordered ones. Version 7, standardised more recently in RFC 9562, solves the same sorting problem a different way: it starts with a plain 48-bit Unix millisecond timestamp — the same kind of timestamp used throughout JavaScript and most modern APIs — followed by cryptographically random bits, giving you an identifier that is sortable, timestamp-readable, and increasingly the default recommendation for new systems. Version 8 is the specification's deliberately open slot for vendor-specific layouts; this tool's implementation seeds it with the current timestamp for extra uniqueness assurance and fills the rest with secure random bits, tagged correctly with the version 8 and RFC 4122/9562 variant markers, and is presented as clearly experimental since v8's internal layout is not standardised beyond those marker bits.
Versions 3 and 5 solve a different problem entirely: instead of a fresh random or time-based identifier, they produce a deterministic UUID from a namespace and a name, using MD5 for version 3 and SHA-1 for version 5. The same namespace and the same name always hash to exactly the same UUID, which is exactly what you want when you need a stable identifier derived from something that already exists — a URL, a domain, an e-mail address, a username or a filename — without maintaining a separate lookup table anywhere. This tool implements MD5 and SHA-1 from scratch in plain JavaScript (no external cryptography library, and definitely no AI involved) and both were checked bit-for-bit against the official RFC 4122 test vectors — hashing the DNS namespace together with the name "www.example.com" reproduces the exact UUIDs published in the specification, which is the strongest possible confirmation that the hashing and bit-layout logic are correct. Four standard namespaces are built in — DNS, URL, OID and X.500 — or you can supply any UUID of your own as a custom namespace, letting you build a private, collision-free namespace for your own application.
The Validate tab turns the tool around: paste in any UUID, however it's formatted — with or without hyphens, wrapped in braces, parentheses or quotes — and it tells you precisely what it is. A valid UUID reports its version and its variant (the RFC 4122/9562 layout used by virtually everything today, the older NCS layout, the Microsoft GUID layout, or a reserved variant), and for the three time-based versions it decodes the embedded timestamp back into a human-readable date and time, computed directly from the bits rather than guessed. An invalid UUID gets something far more useful than a bare "invalid" message: the validator walks the string character by character against the expected 8-4-4-4-12 pattern and reports the exact position and reason the first mismatch occurs — a misplaced hyphen, an out-of-range character, or the wrong overall length — so you can fix a malformed value instead of hunting for the typo by eye.
Around these generators sits everything a developer actually needs day to day. Bulk generation runs from a single UUID up to a thousand at once, either through quick preset buttons or a custom quantity field, and a 1,000-UUID v4 batch typically completes in a few milliseconds — the statistics panel shows you the exact generation time and UUIDs-per-second figure for whatever you just produced. Formatting covers both individual values (plain, wrapped in braces, parentheses or quotes, uppercase or lowercase, with or without hyphens) and the batch as a whole (a JSON array, a CSV column, an XML document, or a ready-to-run SQL INSERT statement), plus a custom prefix, suffix, separator and optional line numbering for developers who need output that slots directly into existing code or scripts. Dedicated export buttons download the batch as TXT, CSV, JSON, XML or SQL, one-click clipboard copy grabs the current on-screen format, and a QR code exporter turns a single UUID — or up to twenty-five at once — into a scannable code. A local history, saved only in your browser, keeps every UUID you've generated across sessions, searchable and filterable by version or favourite status, with bulk copy, download and delete for whatever you've filtered down to, and a log of your recent downloads. And because every calculation — random generation, hashing, formatting, validation — runs locally using the Web Crypto API and hand-written routines, your identifiers, your history and your namespace values never leave your device; the tool keeps working offline once loaded, needs no account, and includes no AI-powered features of any kind.
The same guide in Hindi / यही जानकारी हिंदी में।
Professional UUID Generator एक फ्री, पूरी तरह ब्राउज़र-आधारित टूल है जो Universally Unique Identifiers — वे 128-bit values जो आधुनिक software में हर जगह database rows, session tokens, distributed-system messages, file identifiers और API resources को नाम देने के लिए इस्तेमाल होते हैं, बिना किसी central authority की मदद के अगला नंबर बांटे — generate और inspect करने के लिए है। जो एक साधारण "random UUID दो" बटन के रूप में शुरू हुआ था, वह अब हर सक्रिय UUID version, एक पूरा validator, deterministic name-based generation, formatting और export की सुविधाएं, और एक local history वाला पूरा workbench बन गया है — फिर भी मूल टूल का वादा वैसा ही है: सब कुछ आपके डिवाइस पर, तुरंत होता है, कुछ भी कहीं upload नहीं होता।
टूल के केंद्र में सात UUID generators हैं, हर एक अपने governing specification से बिल्कुल मेल खाता हुआ, अनुमानित नहीं। Version 4, आधुनिक software का सबसे इस्तेमाल होने वाला version, ब्राउज़र के Web Crypto API से लिया गया 122 bits का cryptographically secure randomness है — वही स्रोत जो encryption keys के लिए इस्तेमाल होता है — जिसमें version और variant bits सही सेट किए जाते हैं ताकि कोई भी RFC-aware system इसे सही पहचान सके। Version 1 इसके विपरीत तरीका अपनाता है: pure randomness के बजाय यह 15 अक्टूबर 1582 (वह तारीख़ जब Gregorian calendar अपनाया गया, मूल 1980 के दशक के DCE specification द्वारा चुनी गई) से 100-nanosecond अंतराल में गिना गया 60-bit timestamp, एक random clock sequence, और एक node identifier मिलाकर बनाता है। असली UUID v1 implementations किसी physical machine पर उस मशीन के network card address को node ID के रूप में इस्तेमाल करते हैं; ब्राउज़र के पास ऐसा कुछ नहीं होता, इसलिए यह टूल वही करता है जिसकी RFC 4122 उस स्थिति में स्पष्ट रूप से अनुमति देता है — एक random node ID बनाता है और उसका multicast bit सेट करता है, जो किसी भी पढ़ने वाले को बताता है कि node हिस्सा असली hardware address नहीं है। Version 6 उन्हीं time-based fields को लेकर उन्हें इस तरह पुनर्व्यवस्थित करता है कि सबसे significant bits पहले आएं, जिसका मतलब है — v1 के विपरीत — v6 UUIDs का एक batch plain text strings के रूप में सही ढंग से sort होता है, यह गुण database engineers के लिए बहुत मायने रखता है क्योंकि sequential, sorted primary keys random order वाली keys से कहीं ज़्यादा कुशलता से insert होती हैं। Version 7, हाल ही में RFC 9562 में मानकीकृत, वही sorting समस्या अलग तरीके से हल करता है: यह एक सादे 48-bit Unix millisecond timestamp — वही तरह का timestamp जो JavaScript और ज़्यादातर modern APIs में इस्तेमाल होता है — से शुरू होता है, उसके बाद cryptographically random bits आते हैं, जो एक ऐसा identifier देता है जो sortable है, timestamp-readable है, और नए systems के लिए तेज़ी से default सुझाव बनता जा रहा है। Version 8 specification का जान-बूझकर खुला रखा गया slot है vendor-specific layouts के लिए; इस टूल का implementation इसे अतिरिक्त uniqueness के लिए current timestamp से seed करता है और बाकी हिस्सा secure random bits से भरता है, version 8 और RFC 4122/9562 variant markers के साथ सही ढंग से tag किया गया, और स्पष्ट रूप से experimental के रूप में प्रस्तुत किया गया है क्योंकि v8 का आंतरिक layout उन marker bits से आगे मानकीकृत नहीं है।
Versions 3 और 5 बिल्कुल अलग समस्या हल करते हैं: एक नए random या time-based identifier के बजाय, वे एक namespace और एक name से एक deterministic UUID बनाते हैं, version 3 के लिए MD5 और version 5 के लिए SHA-1 इस्तेमाल करते हुए। एक ही namespace और एक ही name हमेशा बिल्कुल एक ही UUID में hash होते हैं, जो बिल्कुल वही है जो आपको चाहिए जब आपको किसी पहले से मौजूद चीज़ से एक स्थिर identifier चाहिए — एक URL, एक domain, एक e-mail address, एक username, या एक filename — बिना कहीं भी अलग lookup table बनाए रखे। यह टूल MD5 और SHA-1 को शुरू से सादे JavaScript में implement करता है (कोई बाहरी cryptography library नहीं, और निश्चित रूप से कोई AI शामिल नहीं), और दोनों को official RFC 4122 test vectors के विरुद्ध bit-for-bit जाँचा गया — DNS namespace को "www.example.com" name के साथ hash करने पर specification में प्रकाशित बिल्कुल वही UUIDs मिलते हैं, जो hashing और bit-layout logic के सही होने का सबसे मज़बूत प्रमाण है। चार standard namespaces built-in हैं — DNS, URL, OID और X.500 — या आप अपना कोई भी UUID custom namespace के रूप में दे सकते हैं, जिससे आप अपने application के लिए एक private, collision-free namespace बना सकते हैं।
Validate tab टूल को उलट देता है: कोई भी UUID पेस्ट करें, चाहे वह किसी भी तरह formatted हो — हाइफ़न के साथ या बिना, braces, parentheses या quotes में लिपटा हुआ — और यह बताता है कि यह ठीक-ठीक क्या है। एक valid UUID अपना version और variant बताता है (RFC 4122/9562 layout जो आज लगभग हर जगह इस्तेमाल होता है, पुराना NCS layout, Microsoft GUID layout, या एक reserved variant), और तीन time-based versions के लिए यह embedded timestamp को वापस पढ़ने-योग्य तारीख़ और समय में decode करता है, अंदाज़ा लगाने के बजाय सीधे bits से गणना करके। एक invalid UUID को सिर्फ़ "invalid" कहने के बजाय कहीं ज़्यादा उपयोगी जवाब मिलता है: validator string को character-by-character 8-4-4-4-12 pattern के विरुद्ध चलाता है और पहला mismatch कहाँ और क्यों होता है, यह बताता है — एक गलत जगह पर hyphen, एक range से बाहर character, या ग़लत कुल लंबाई — ताकि आप आँख से typo ढूँढ़ने के बजाय ग़लत value को ठीक कर सकें।
इन generators के आसपास हर वह चीज़ है जो एक developer को रोज़ चाहिए। Bulk generation एक UUID से लेकर एक हज़ार तक चलती है, या तो quick preset buttons से या एक custom quantity field से, और एक 1,000-UUID वाला v4 batch आमतौर पर कुछ ही milliseconds में पूरा हो जाता है — statistics panel आपको वह exact generation time और UUIDs-per-second आँकड़ा दिखाता है जो आपने अभी बनाया। Formatting अकेले values (plain, braces, parentheses या quotes में लिपटा, uppercase या lowercase, हाइफ़न के साथ या बिना) और पूरे batch (एक JSON array, एक CSV column, एक XML document, या एक तुरंत चलाने-योग्य SQL INSERT statement) दोनों को कवर करती है, साथ ही एक custom prefix, suffix, separator, और वैकल्पिक line numbering उन developers के लिए जिन्हें ऐसा output चाहिए जो सीधे मौजूदा code या scripts में fit हो जाए। अलग export बटन batch को TXT, CSV, JSON, XML या SQL के रूप में download करते हैं, एक-क्लिक clipboard copy वर्तमान on-screen format को उठाती है, और एक QR code exporter एक UUID — या एक साथ पच्चीस तक — को एक scannable code में बदल देता है। सिर्फ़ आपके ब्राउज़र में सहेजी गई एक local history हर session में आपके बनाए हर UUID को रखती है, version या favourite status से searchable और filterable, filter की गई किसी भी चीज़ के लिए bulk copy, download और delete के साथ, और आपके recent downloads का एक log। और क्योंकि हर calculation — random generation, hashing, formatting, validation — Web Crypto API और hand-written routines का इस्तेमाल करते हुए स्थानीय रूप से चलता है, आपके identifiers, आपकी history और आपके namespace values कभी आपका डिवाइस नहीं छोड़ते; लोड होने के बाद टूल offline काम करता रहता है, किसी account की ज़रूरत नहीं, और इसमें किसी भी तरह की कोई AI-powered feature शामिल नहीं है।
Yes, completely free with no signup, no account and no limit on how many UUIDs you generate. / हाँ, यह पूरी तरह मुफ़्त है, बिना signup या account के।
No. Every UUID is generated locally in your browser using the Web Crypto API and hand-written hash routines; nothing is ever sent to a server. / नहीं, सब कुछ आपके ब्राउज़र में ही generate होता है।
Version 4 (random) for general-purpose unique IDs, or version 7 if you want your IDs to sort chronologically and embed a timestamp. / सामान्य उपयोग के लिए v4, समय-क्रम में sort करने के लिए v7 चुनें।
Both encode the same kind of Gregorian timestamp, but v6 rearranges the bits most-significant-first so v6 UUIDs sort correctly as plain strings, while v1 does not. / v6 के bits इस तरह क्रमबद्ध होते हैं कि वे सही तरीके से sort हों, v1 के नहीं।
Browsers have no access to a device's real network hardware address for privacy and security reasons, so this tool uses RFC 4122's explicitly permitted fallback: a random node ID with its multicast bit set. / privacy कारणों से browser को MAC address नहीं मिलता, इसलिए RFC-अनुमत random node ID इस्तेमाल होता है।
UUID v7 embeds a plain Unix millisecond timestamp followed by random bits (RFC 9562), making it sortable and timestamp-readable — many new databases now recommend it as a primary key. / v7 में Unix timestamp होता है, इसलिए यह sortable और नई systems में लोकप्रिय है।
Version 8 is the specification's deliberately open, vendor-defined layout; this tool seeds it with a timestamp and fills the rest with secure random bits, marked clearly as experimental. / v8 एक खुला, vendor-defined layout है; इसे experimental माना जाए।
Both are deterministic, name-based UUIDs — the same namespace and name always produce the same UUID — but v3 uses the older MD5 hash while v5 uses the stronger, recommended SHA-1 hash. / दोनों deterministic हैं; v5 (SHA-1) v3 (MD5) से बेहतर माना जाता है।
The four standard RFC 4122 namespaces — DNS, URL, OID and X.500 — plus the option to supply any UUID of your own as a custom namespace. / DNS, URL, OID, X.500 के साथ अपना custom namespace भी दे सकते हैं।
Yes, for v3 and v5 — that's the whole point of name-based UUIDs. Version 1, 4, 6, 7 and 8 are never deterministic; every generation is different. / v3/v5 हमेशा एक जैसा UUID देते हैं; बाकी versions हर बार अलग।
Up to 1,000 in a single batch, using quick preset buttons (1/10/50/100/500/1000) or a custom quantity field. / एक बार में अधिकतम 1000 UUID।
A batch of 1,000 v4 UUIDs typically completes in a few milliseconds; the Statistics panel shows the exact generation time and UUIDs-per-second for your last batch. / 1000 UUIDs कुछ ही milliseconds में बन जाते हैं।
Yes. Paste any UUID into the Validate tab, in any common format (with/without hyphens, braces, parentheses or quotes), to see its version, variant and — where applicable — its embedded timestamp. / किसी भी UUID को Validate tab में paste करके जाँच सकते हैं।
If a pasted value isn't a valid UUID, the tool highlights the exact character and explains why — a misplaced hyphen, an invalid character, or the wrong length — instead of a generic error. / गलत UUID में सही जगह और कारण दिखाया जाता है।
The variant identifies which historical UUID layout a value follows — RFC 4122/9562 (used by virtually everything today), the legacy NCS layout, the Microsoft GUID layout, or a reserved variant. / variant बताता है कि UUID कौन-से layout standard का है।
Only for versions 1, 6 and 7, which embed a timestamp in their bits; versions 3, 4, 5 and 8 don't carry a recoverable creation time. / सिर्फ़ v1, v6, v7 में समय embed होता है।
Plain, curly braces, parentheses or quotes per value; uppercase or lowercase; with or without hyphens; a custom prefix, suffix and separator; and whole-batch JSON array, CSV, SQL or XML output. / कई formatting styles उपलब्ध हैं।
TXT, CSV, JSON, XML and SQL file downloads, plus one-click clipboard copy and a QR code exporter for up to 25 UUIDs at once. / TXT, CSV, JSON, XML, SQL और QR code export उपलब्ध हैं।
No — they are local text previews only, showing how your batch would look inside a JSON body, cURL command or GraphQL query. Nothing is sent over the network. / ये सिर्फ़ preview हैं, कोई network call नहीं होती।
Only in this browser's local storage, on your own device — never uploaded. Clear it any time from the History tab. / history सिर्फ़ आपके browser में सहेजी जाती है।
Yes. The History tab has a search box, a version filter and a "favourites only" checkbox, plus bulk copy, download and delete for whatever's currently shown. / History में search और version filter दोनों उपलब्ध हैं।
Yes. The Statistics panel shows unique and duplicate counts for the current batch — duplicates are essentially impossible for random versions but can happen with repeated name-based inputs. / duplicate count Statistics panel में दिखता है।
Ctrl+Enter generates a new batch, Ctrl+D downloads the current batch as TXT, and Ctrl+C (outside any text field) copies the current batch to your clipboard. / Ctrl+Enter, Ctrl+D, Ctrl+C शॉर्टकट काम करते हैं।
Yes, once the page has loaded. The only optional external dependency is the QR code library; every UUID generator, hash function and validator is self-contained. / लोड होने के बाद यह offline भी काम करता है।
Yes. Every generated UUID sets the correct version and RFC 4122/9562 variant bits, and the v3/v5 hashing was verified against the official RFC test vectors. / सभी UUIDs RFC 4122/9562 के अनुरूप हैं।
No. Every UUID, hash and validation result comes from standard, published algorithms with no AI involved anywhere. / नहीं, इसमें कोई AI शामिल नहीं है।