Online Generators: Random Numbers, Passwords, QR Codes

Online Generators: Random Numbers, Passwords, QR Codes

Free online data generators — a collection of tools that create needed values instantly and without registration. All generators run locally in your browser: random numbers, strong passwords, QR codes for links and business cards, unique UUID identifiers. No data is ever sent to a server — everything happens directly on your device, fast and free.

In this article, we'll take a deep dive into each tool: how it works internally, the mathematical principles behind it, when to use it, and which settings actually matter.

Random Number Generator

The Random Number Generator (RNG) produces unpredictable results within specified boundaries. Unlike pseudorandom sequences such as `Math.random()`, our generator uses a cryptographically secure entropy source — `crypto.getRandomValues()` — making the results truly unpredictable.

Random vs Pseudorandom: What's the Difference

The key distinction lies in the entropy source:

Pseudorandom generators (PRNG) — such as `Math.random()`, C's `rand()`, Python's `random()` — use a mathematical algorithm (typically a linear congruential generator or Mersenne Twister) and a seed value. If you know the seed, you can reproduce the entire sequence. Moreover, knowing a few consecutive outputs allows an attacker to compute the internal state and predict future values.

Cryptographically secure generators (CSPRNG) — such as `crypto.getRandomValues()` in browsers, `/dev/urandom` on Linux, `CryptGenRandom` on Windows — harvest entropy from physical sources: keystroke timings, mouse movements, network packets, hardware interrupts, and thermal noise. CSPRNGs pass the next-bit test: given any number of previous bits, you cannot predict the next bit with probability greater than 50%. This property is formally proven for the underlying algorithms (ChaCha20, AES-CTR).

Generation Modes

Our randomizer supports five modes, each designed for a specific task:

• Random Number — set the minimum and maximum, get an integer or decimal result. Range can be anything from −1,000,000 to 1,000,000 and beyond. Integers are generated with uniform probability; for decimals, you can specify the number of decimal places.
• Yes/No — binary decision maker. Each outcome has exactly a 50% probability, independent of previous flips. Ideal for breaking decision paralysis when stuck between two equal options.
• Dice — roll one or more dice. Supports all standard types: d4, d6, d8, d10, d12, d20, d100. Roll any number of dice — from one to a hundred. The sum of multiple dice follows a normal distribution (Central Limit Theorem): middle values appear far more often than extremes.
• Random Card — draw a card from a standard 52-card deck (4 suits, 2 through Ace). Each subsequent card is drawn from the remaining deck — no repeats until the deck is exhausted. The probability of drawing a specific card changes with each draw — this is hypergeometric distribution.
• Random List Element — enter your items (one per line or comma-separated) and the randomizer picks one. Ideal for giveaways, task assignment, and winner selection. Supports any text including emoji and Unicode symbols.

How It Works: Uniform Distribution Math

The generator produces a uniform distribution — each possible outcome has an equal probability. The formula for a random integer in range `[min, max]`:

X = min + ⌊random × (max − min + 1)⌋

Where `random` is a value in `[0, 1)` obtained from `crypto.getRandomValues()` and normalized by dividing by `2^32`. For decimal numbers:

X = min + random × (max − min)

When rolling N dice with M faces each, the total number of outcomes is `M^N`. For example, two six-sided dice (2d6) yield 36 possible combinations, from 2 to 12. The probability of a specific sum:

P(sum = S) = number of combinations yielding S / 36

Distribution for 2d6:

| Sum | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | |-----|---|---|---|---|---|---|---|----|----|----| | Combinations | 1 | 2 | 3 | 4 | 5 | 6 | 5 | 4 | 3 | 2 | 1 | | Probability | 2.8% | 5.6% | 8.3% | 11.1% | 13.9% | 16.7% | 13.9% | 11.1% | 8.3% | 5.6% | 2.8% |

Sum 7 is the most probable (6 out of 36 combinations), while 2 and 12 are the rarest. This explains why difficulty 7 checks occur most often in tabletop games.

The probability of drawing an Ace from a deck on the first draw is `4/52 ≈ 7.7%`. When drawing without replacement (hypergeometric distribution), the probability shifts. If the first 10 cards were not Aces, the chance of drawing an Ace on the eleventh draw becomes `4/42 ≈ 9.5%`. If one Ace has already been drawn — `3/42 ≈ 7.1%`.

Use Cases for the Random Number Generator

• Giveaways and contests — objective winner selection from a participant list. Unlike subjective picking, a random result eliminates bias and appears fair to all participants. Simply paste the list of names and click "Pick."
• Random sampling — selecting respondents for surveys, users for A/B testing, or a control group for experiments. Critical requirement: the sample must be truly random, or the experiment results won't be statistically significant.
• Tabletop and role-playing games — a replacement for physical dice. Support for all types (d4 for daggers, d6 for swords, d8 for bows, d10 for spells, d20 for skill checks, d100 for random event tables) makes this randomizer a universal tool for any RPG game master.
• A/B testing — assigning users to variants: 50/50, 70/30, or multi-armed bandit with several options. Random assignment is a fundamental requirement for valid A/B testing; without it, results will be biased.
• Test data generation — populating databases with random values within specified ranges for load testing. Create 10,000 users with ages 18–75, salaries 30,000–300,000, and random roles.
• Decision making — flip a coin (Yes/No mode) when stuck between two equal options. Research shows the act of flipping itself helps: at the moment of the toss, you often realize which outcome you actually want.

Distribution Histogram: Why It Matters

Every generated result lands on a histogram showing the actual distribution of values. This isn't just a visualization — it's a generator quality verification tool.

With 10 rolls, the distribution may be chaotic — say, 4 heads and 6 tails. With 100 rolls, the spread narrows: 45–55. With 10,000 rolls, the distribution is nearly perfect: 4,980–5,020. This is the Law of Large Numbers in action: the more trials, the closer empirical frequency gets to theoretical probability.

The histogram lets you personally verify that the generator isn't rigged. Open the tool, make 1,000 dice rolls — each face should appear roughly 167 times.

Frequently Asked Questions

How random are the results?
We use `crypto.getRandomValues()` — a cryptographically secure pseudorandom number generator (CSPRNG) based on ChaCha20, built into every modern browser. Entropy is collected from dozens of sources. For any practical task — giveaways, games, experiments, A/B tests — this is more than sufficient. CSPRNGs are indistinguishable from truly random sequences for any observer with finite computational resources.

Can the next number be predicted?
No. CSPRNGs are designed so that knowing the previous N results gives zero information about result N+1. This is formally guaranteed by ChaCha20's cryptographic properties. Unlike `Math.random()`, whose internal state can be recovered from 5–10 consecutive values using a Z3 solver.

How is your generator different from others?
The key difference is transparency. You see the actual result distribution on the histogram and can verify its uniformity yourself. The source code is open, generation happens locally in the browser — no dice rolls are sent to a server. We also support non-standard dice (d8, d10, d12, d20, d100) that are rarely found in online randomizers.

Do I need to register to use it?
No. All txtly.ru tools work without registration, without ads, and without data collection. Open the page — start using.

Open Random Number Generator →

Password Generator

A password generator creates cryptographically strong passwords resistant to brute-force and dictionary attacks. In an era where database breaches happen daily, using unique and complex passwords for every service isn't just a recommendation — it's basic digital hygiene.

What Makes a Password Strong: Two Pillars

A strong password has two independent properties:

1. High entropy — high unpredictability, measured in bits. Each additional bit of entropy doubles the number of possible combinations and, correspondingly, the time needed for exhaustive search.
2. Uniqueness — the password is used in exactly one place. If service A's database leaks, your service B password remains safe. This property is independent of complexity: even a very complex password reused on two sites becomes vulnerable when one of them is breached.

Generation Parameters and Their Effect on Strength

• Password length (4–128 characters) — the most important parameter. Every additional character multiplies the number of combinations by the alphabet size. NIST SP 800-63B recommendation: minimum 8 characters for user passwords, 16+ for service accounts.
• Uppercase letters (A–Z, 26 characters) — adding this set doubles the search space compared to lowercase alone. Even one random uppercase in the middle of a password breaks the "first letter uppercase" pattern.
• Lowercase letters (a–z, 26 characters) — the foundation of any password, the minimum required set.
• Digits (0–9, 10 characters) — break dictionary attacks that only iterate through letters. An 8-letter password has 208 billion variants; 8 letters plus digits gives 2.8 trillion.
• Special characters (!@#$%^&* and others, up to 32 characters) — highest entropy gain per character. However, not all services support them; some restrict the allowed set.
• Exclude similar characters — removes confusable pairs: `l` and `1` and `I`, `0` and `O`, `2` and `Z`, `5` and `S`, `8` and `B`. Critical for passwords that must be typed manually (Wi-Fi, server console) or dictated over the phone.

Password Entropy: The Full Formula

Entropy is measured in bits and shows how much information a password carries. The formula:

H = L × log₂(N)

Where:

• H — entropy in bits
• L — password length in characters
• N — alphabet size (possible characters at each position)

Number of possible combinations: `K = N^L = 2^H`. Time for exhaustive search at V attempts/second: `T = K / V`.

Practical table for different configurations at 10⁹ attempts/second (typical mid-size GPU cluster speed):

Key takeaway: length matters more than character complexity. A 16-character lowercase-only password (75 bits) is more secure than an 8-character password with full alphabet (52 bits). And it's much easier to remember.

Why Password Patterns Don't Work

The human brain systematically fails at generating "random" passwords. Research on millions of leaked passwords reveals persistent patterns:

• Keyboard sequences: `qwerty`, `qwerty123`, `1qaz2wsx`, `zxcvbnm`
• Dates and years: `1991`, `2000`, `march2020`, `password2024`
• Character substitutions (leetspeak): `p@ssw0rd` instead of `password`, `h4ck3r` instead of `hacker` — attackers have long incorporated these into their cracking rules
• Appending `!` or `1`: `password!`, `myname1`, `letmein!` — meet the "at least one special character or digit" requirement without adding real entropy
• Sports teams, names, brands: `liverpool`, `starwars`, `nike123`

All these patterns are well-represented in hashcat and John the Ripper dictionaries. A properly generated password like `x7Kp-m3Qw_zR9` contains no recognizable words or patterns.

The Generator + Password Manager Workflow

Remembering 50+ unique passwords like `x7Kp-m3Qw_zR9` is impossible — and unnecessary. The correct workflow:

1. Generate a unique, complex password using our generator.
2. Save it in a password manager (Bitwarden — open-source, 1Password, KeePass, built-in Chrome/Safari/Firefox manager).
3. Remember just one password — the master password for your manager. It should be long (20+ characters) but memorable: use the Diceware method — 6–8 random words separated by spaces.

NIST and OWASP Recommendations

Modern security standards (NIST SP 800-63B, 2024) recommend:

• Verify passwords against breach databases — even a complex password may be compromised if it has appeared in a breach. Use Have I Been Pwned to check.
• Don't require periodic password changes — forcing changes every 90 days leads users to create weaker passwords or append counters (`MyPass1`, `MyPass2`, `MyPass3`). Only change passwords when compromise is suspected.
• Encourage length over complexity — 20 random lowercase letters are more secure than 8 characters with special symbols. And easier for users.
• Implement two-factor authentication (2FA) — even the strongest password can be phished. 2FA (TOTP, hardware key) is the second line of defense.

Frequently Asked Questions

How long should a password be?
Minimum 12 characters for regular accounts, 16+ for important ones (email, banking, hosting), 20+ for critical ones (domain registrar, corporate VPN). Every additional 2–3 characters increase security by hundreds of times.

Do I need special characters if the password is long?
Mathematically — no. A 20-character lowercase-only password has ~94 bits of entropy, which is more than sufficient. However, many services require special characters, so it's best to generate with the full alphabet — a universal password passes validation on any site.

Is generating passwords in the browser safe?
Yes. Generation happens locally using `crypto.getRandomValues()` — the same API used by browser password managers and cryptographic extensions. The generated password is never sent to a server, never saved to localStorage, and never appears in logs. Once you close the tab, it's unrecoverable.

Can online password generators be trusted?
It depends. If the generator sends requests to a server — no (the server could save your password). Our generator works entirely locally — you can disconnect from the internet, and it continues working. You can verify this via DevTools: open the Network tab and confirm that clicking "Generate" sends zero requests.

What if the service limits password length?
Some legacy systems restrict passwords to 8, 10, or 12 characters. In this case, use the maximum allowed length with the full alphabet. If the limit is outdated (e.g., 8 characters), enable 2FA — it compensates for the short password's weakness.

Open Password Generator →

QR Code Generator

A QR Code (Quick Response Code) is a two-dimensional matrix barcode capable of storing up to 4,296 alphanumeric characters or 7,089 digits. Developed by Japanese company Denso Wave in 1994 for tracking auto parts on assembly lines, QR codes are now the most common way to quickly bridge the physical and digital worlds.

QR Code Anatomy

A QR code consists of black and white modules (squares) on a square matrix. Each element serves a precisely defined function:

• Finder Patterns — three large 7×7-module squares in the top-left, top-right, and bottom-left corners. The scanner locates these three squares, determines the code's orientation, and corrects for perspective distortion. The fourth corner is intentionally left blank — this lets the scanner distinguish top from bottom.
• Alignment Patterns — small 5×5 squares, appearing from version 2 (25×25 matrix) onward. Help restore the code's geometry when printed on uneven surfaces or captured at an angle. The higher the version, the more alignment patterns.
• Timing Patterns — alternating black and white modules between finder patterns. The scanner uses these to determine individual module size and overall matrix dimensions.
• Format and Version Information — encoded bits near the finder patterns. Contain the error correction level, data mask, and code version.
• Data and Error Correction Codewords — the payload (your URL or text) and Reed-Solomon redundant code for recovery from damage.

Error Correction Levels and Reed-Solomon Codes

Error correction is the key technology behind QR codes. The Reed-Solomon algorithm adds redundant symbols to the original data, allowing recovery of lost bytes. Four levels:

Higher error correction makes the QR code larger (more redundant data) but more resilient. An interesting effect: at level H, you can overlay a logo on the center of the QR code, and the code remains scannable — the redundant data compensates for the obscured area. For most tasks, we recommend level M — a good balance of size and reliability.

Data Capacity: What Fits in a QR Code

Maximum capacity depends on the version (matrix size) and error correction level. Table for version 40 (177×177 modules, maximum):

For a typical URL (30–50 characters), lower QR code versions with a 21×21 or 25×25 matrix are sufficient — compact, fast to scan, and highly readable.

Data Formats: Not Just Links

A QR code can encode various data types. Our generator supports:

• Plain text or URL — universal format. If text starts with `http://` or `https://`, the scanner automatically offers to open a browser.
• Contact data (vCard) — format:

  BEGIN:VCARD
  VERSION:3.0
  FN:John Smith
  TEL:+1234567890
  EMAIL:john@example.com
  URL:https://example.com
  END:VCARD

  Upon scanning, the phone saves the contact to the address book. Perfect for business cards.
• Wi-Fi — format:

  WIFI:S:MyNetwork;T:WPA;P:mypassword;;

  Upon scanning, the smartphone connects to the network without manually entering the password. Excellent for guest Wi-Fi in cafes, offices, and events.
• Geolocation — `geo:40.7128,-74.0060` — opens maps at the specified point.
• Calendar event — link to `.ics` or Google Calendar.

QR Code Use Cases

• Business cards and networking — one QR code with a vCard replaces a stack of paper cards. In a face-to-face meeting, the person scans the code and saves your contact in 5 seconds.
• Restaurant menus — a QR code on the table leads to the online menu. No need to reprint menus when prices or dishes change. Guests view the menu on their phones — especially relevant in the post-COVID world.
• Payments — a link to a payment page. Works with any payment system or payment gateway. Convenient for freelancers, small shops, and donations.
• Guest Wi-Fi — a sign with a QR code at reception or in the guest area. Guests connect without asking "what's the Wi-Fi password?"
• Product marking and logistics — serial numbers, links to user manuals, warranty cards, shipment tracking. This is what QR codes were originally invented for.
• Tickets and boarding passes — airline tickets, concert and theater tickets. The QR code contains the booking reference and verification code.
• Educational materials — a QR code in a textbook leads to a video demonstration of an experiment or an interactive exercise.

Frequently Asked Questions

Which error correction level should I choose?
For screens and web — L (compact code). For print — M (recommended, good balance). For outdoor advertising and packaging — Q or H. If you plan to add a logo in the center — definitely H.

Can I add a logo to the center of the QR code?
Yes. Download our QR code as PNG or SVG and add the logo in any editor. At error correction level H, the logo can cover up to 30% of the code area. Important: after adding the logo, always test readability with several phones and from different angles. Sometimes logo contrast interferes with scanning — in that case, add a white border around the logo.

Does a QR code expire?
The code itself has no expiration — it simply encodes data. But if the encoded URL changes, the code stops working. For long-term use, set up a redirect on your site or use your own short link whose destination can be changed.

What is the minimum print size?
Recommended minimum is 2 × 2 cm at 300 dpi. A smaller size means the phone camera can't distinguish individual modules. The higher the QR code version (larger matrix) — the larger the print should be.

PNG or SVG — which should I choose?
PNG — for screens: websites, presentations, email signatures, messengers. SVG — for print: business cards, flyers, banners, packaging. SVG can be scaled to billboard size without quality loss. For most tasks, we recommend downloading both formats.

Why is your QR generator better than others?
No watermarks, no advertising logos in the code, open source, local browser generation, choice between PNG and SVG, selectable error correction level, ability to encode any text — not just URLs, but also vCard, Wi-Fi, geolocation.

Open QR Code Generator →

UUID/GUID Generator

UUID (Universally Unique Identifier) is a 128-bit identifier standardized in RFC 9562 (formerly RFC 4122). It enables creating globally unique identifiers without a centralized issuing authority and without coordination between systems. This is a foundational technology for distributed systems.

Why UUID Exists

In a centralized system, the database issues IDs: `INSERT` returns the next number (1, 2, 3...). In a distributed system, this approach breaks:

• Two servers simultaneously create records with ID=42 — conflict.
• A server can't generate an ID without querying the master database — bottleneck.
• A mobile app without internet can't create a record — no ID can be assigned.

UUID solves all three problems. Each node generates IDs independently, and the probability of collision is negligibly small.

UUID Format

A UUID is written as 36 characters: `xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx`, where `x` is a hexadecimal digit (0–9, a–f). Example:

550e8400-e29b-41d4-a716-446655440000

Breakdown of UUID v4 structure (the most popular version):

Total entropy of UUID v4: 122 random bits (128 minus 6 fixed version and variant bits). Number of possible combinations:

2^122 ≈ 5,316,911,983,139,663,491,615,228,241,121,400,000

This number is roughly equal to the number of atoms in 10,000 Earth-sized planets. The probability of collision when generating 1 billion UUIDs per second for 100 years is less than `10^-15` — essentially zero.

Comparing UUID Versions

The standard defines 8 UUID versions. Each solves a different problem:

For most tasks, UUID v4 is the optimal choice. It doesn't reveal creation time or MAC address, is trivially generated (requires no coordination), and collision probability is negligible. If you're designing a new database and index performance matters — consider UUID v7.

UUID in Databases: Practical Considerations

Not all DBMS handle UUID equally well:

PostgreSQL — native `UUID` type (16 bytes). Indexes work efficiently, built-in `gen_random_uuid()` function. UUID v4 fragments B-tree indexes due to random ordering, but for most projects this isn't critical. For high-load systems, use UUID v7 or `uuid_generate_v7()` from the `pg_uuidv7` extension.

MySQL/MariaDB — no native UUID type. Storing as `CHAR(36)` uses 36 bytes instead of 16, indexes suffer. Recommendation: store UUID as `BINARY(16)` with conversion via `UUID_TO_BIN()` and `BIN_TO_UUID()`. This reduces size by 2.25× and improves index performance.

SQLite — no native UUID type. Store as `TEXT` (36 bytes) or `BLOB` (16 bytes). For small projects, the difference is negligible.

MongoDB — uses ObjectID (12 bytes) by default, but UUID (as string or BinData) is also supported.

UUID vs Auto-Increment: When to Use Which

Frequently Asked Questions

Can two UUID v4 ever be identical?
Mathematically — yes. Practically — no, with a probability bordering on impossibility. You're more likely to guess a Bitcoin private key three times in a row than to encounter a UUID v4 collision under normal operation. For scale: if all 8 billion people on Earth generated 1 billion UUIDs per second for 100 years, the total generated would be ~2.5 × 10^28, and the probability of at least one collision would be under 0.0000000001%.

How many UUIDs can I generate at once?
Our generator creates up to 100 UUIDs per click. This is enough for populating a test database, creating a batch of identifiers for bulk insertion, or generating trace IDs for a group of requests.

What's the difference between UUID and GUID?
Essentially none. GUID (Globally Unique Identifier) is Microsoft's term, UUID is the IETF term. Both refer to a 128-bit identifier per RFC 9562. Technically identical. Some Microsoft generators produce GUIDs with a slightly different variant bit structure, but for practical purposes there's no difference.

Can you tell where and when a UUID was created from its value?
UUID v4 — no. It's just 122 random bits. UUID v1 contains a MAC address and timestamp; UUID v7 contains a Unix timestamp. If anonymity matters to you — use v4.

Why do UUIDs have dashes?
Purely for readability. The dashes carry no semantic meaning and can be omitted: `550e8400e29b41d4a716446655440000` is the same UUID. Some databases store UUIDs without dashes to save 4 bytes.

Can a UUID be decrypted?
UUID v4 contains no encrypted data. It's a random number — you can't "decrypt" it because nothing is encrypted in it. If you need a format containing encrypted data (e.g., user ID + expiration), use JWT or signed tokens.

Open UUID Generator →

See Also

• Business Calculators — percentages, VAT, margin, ROI, unit economics, SWOT, RACI
• Math Tools — equation solver, numeral systems, derivatives, integrals
• Converters — unit conversion, currency, data formats, measurement
• Design Tools — colors, gradients, palettes, shadow and border generators