Generators Tools
Create test data, unique identifiers, placeholder content, and code snippets. Essential tools for development and testing workflows.
Test data should look like production data. These generators produce UUIDs, passwords, hashes, QR codes, placeholder text, fake personas, slugs, gradients, and more - all locally in your browser, ready to paste into test fixtures and seed scripts.
19 tools availableUUID Generator
Generate UUID v1, v4, v5, or NIL UUIDs with bulk generation options
Password Generator
Create secure passwords with customizable length and complexity
Lorem Ipsum Generator
Generate placeholder text for design mockups
Fake Data Generator
Generate realistic fake names, emails, addresses, and more
Hash Generator
Generate MD5, SHA-1, SHA-256, SHA-512 cryptographic hashes
HMAC Generator
Generate and verify HMAC-SHA256/384/512 signatures
QR Code Generator
Create QR codes from text, URLs, and other data
Color Palette Generator
Generate harmonious color schemes and palettes
Slug Generator
Convert text to URL-friendly slugs
Gradient Generator
Create beautiful CSS gradients with live preview
Box Shadow Generator
Design CSS box shadows with visual controls
Meta Tag Generator
Generate SEO-friendly meta tags for your pages
.htaccess Generator
Create Apache .htaccess configuration files
Favicon Generator
Create favicons in multiple sizes from any image
SVG Optimizer
Optimize and minify SVG files for the web
Placeholder Image
Generate placeholder images with custom dimensions and colors
Invoice PDF Generator
Create professional invoices and download as PDF
Test Credit Card Generator
Luhn-valid test card numbers with brand prefixes
Random User Agent Generator
Realistic test user agent strings for QA and compat testing
Generated data is only useful when the identifier rules are real
A generator is a promise about format. The output has to satisfy a rule someone else published, or the fixture it seeds fails in a way that looks like an application bug.
UUIDs are 128 bits, and version 7 is ordered by time
RFC 9562 fixes the size first: "The UUID format is 16 octets (128 bits) in size". The versions differ in where those bits come from, and that choice is the reason to pick one. UUIDv7 "features a time-ordered value field derived from the widely implemented and well-known Unix Epoch timestamp source, the number of milliseconds since midnight 1 Jan 1970 UTC, leap seconds excluded." A version 4 value is random and carries no order; a version 7 value sorts by creation time, which is what makes it kind to a database index. Neither is a security token.
Passwords: length is the requirement, composition is not
The current federal guidance is unusually direct. NIST SP 800-63B requires that verifiers "SHALL require passwords that are used as a single-factor authentication mechanism to be a minimum of 15 characters in length", and then removes the old habit: "Other composition requirements for passwords SHALL NOT be imposed." A generator that forces a symbol and a digit produces passwords that satisfy a policy the standard advises against.
A hash proves integrity; an HMAC proves who sent it
RFC 6234 publishes the SHA-2 family used by the hash tools - SHA-224, SHA-256, SHA-384 and SHA-512 - and an unkeyed digest can be recomputed by anyone holding the bytes, which is what makes it a good integrity check. HMAC adds the missing half: RFC 2104 describes it as "a mechanism for message authentication using cryptographic hash functions", used "in combination with a secret shared key". A checksum comparison proves the bytes did not change; an HMAC comparison proves they came from someone holding the key.
Slugs, fake records and gradients: normalisation is the whole job
A slug is a URL path segment, so URL rules apply. Unicode defines the conversion path for internationalised labels in UTS #46, where "The operation corresponding to ToASCII of [RFC3490] is defined by the following steps" - a slug generator that only lowercases and swaps spaces for hyphens will disagree with that pipeline on non-ASCII input. Fake persona data has no standard, so the honest test is consistency: the same seed must produce the same record, and every field must satisfy the format the application validates. A gradient is a CSS image rather than a file: the specification says "A gradient is an image that smoothly fades from one color to another", and notes that "the gradient itself has no natural dimensions", so a generated gradient only means something inside a box with a size.
| Generator | What the output must satisfy | The rule with a number or a name | Source |
|---|---|---|---|
| UUID | 16 octets, with the version in the version field | 128 bits; version 7 counts Unix-epoch milliseconds | RFC 9562 |
| Password | the account's length policy | single-factor minimum of 15 characters; no composition rules | NIST SP 800-63B |
| Hash | one digest per input | SHA-224, SHA-256, SHA-384 or SHA-512 | RFC 6234 |
| HMAC | a digest plus the key that produced it | keyed message authentication over an iterative hash | RFC 2104 |
| Slug | a valid URL path segment | ToASCII processing for non-ASCII labels | UTS #46 |
| Gradient | a CSS image with a box to fill | no natural dimensions of its own | CSS Images Level 3 |
Generate the value, then check it against the rule: the UUID Generator for identifiers, the Password Generator for credentials, the Hash Generator and HMAC Generator for digests, the Slug Generator for paths, the Gradient Generator for CSS values, and the Fake Data Generator for seed records. Pair a fixture with the JSON Schema Validator so the format claim is tested rather than assumed.
Sources: RFC 9562, Universally Unique IDentifiers (UUIDs); NIST SP 800-63B, Digital Identity Guidelines; RFC 2104, HMAC: Keyed-Hashing for Message Authentication; Unicode UTS #46, IDNA Compatibility Processing; W3C CSS Images Module Level 3, gradients.