Output
0
CONTENTS

Core Technology & Features

The core of TrueRNG is a high-reliability client-side random value generator built on the Web Crypto API. Unlike classic pseudo-random algorithms (PRNG like Math.random()), this system utilizes CSPRNG (Cryptographically Secure Pseudo-Random Number Generator), making it suitable for professional and semi-secure scenarios.

Client-Side Privacy

All calculations are performed locally in your browser. The system does not use servers, does not store data in the cloud, and does not transfer any information to third parties.

CSPRNG Std

Cryptographically Secure

No Tracking

Zero data persistence

Offline

Works without internet

Instant

Zero Latency

Matrix 1000x1000 JSON Export Custom Patterns Password Gen
Entropy Source Analysis ● Live

Shannon Entropy Formula

H(X) = -∑ P(x) · log₂(P(x))
  • H(X) : Entropy (measure of unpredictability)
  • P(x) : Probability of character occurrence
import math

def entropy(string):
  prob = [ float(string.count(c)) / len(string) 
           for c in dict.fromkeys(list(string)) ]
  entropy = - sum([ p * math.log(p) / math.log(2.0) 
                    for p in prob ])
  return entropy
MDN Web Crypto API ↗ Wikipedia CSPRNG ↗ NIST Entropy ↗

Basic Generator & Tools

The Basic Generator is the fundamental layer of TrueRNG, engineered to instantly solve 90% of everyday tasks. From simple coin flips to generating massive datasets for Data Science, this mode ensures cryptographic precision without complex configurations. Perfect for random sampling, unbiased selection, and creating statistical datasets or unique IDs in bulk where speed matters.

Single Mode

Designed for immediate results. Features a "Slot Machine" visual effect to demonstrate the randomness process in real-time.

Perfect For
  • ● Giveaways & Lotteries (Fair winner selection)
  • ● Dice Rolling (D6, D20 for tabletop games)
  • ● Quick Decisions (Yes/No, Heads/Tails)
  • ● QA Testing (Input field validation)
  • ● Education (Probability demos)

List Mode

Create ordered arrays of random numbers for analytics or testing. This mode allows generating samples of a specific size with strict control over uniqueness and sorting. An indispensable tool for creating mock data, group distribution, or conducting statistical experiments.

Features
  • ✓ No Repeats: Guarantees unique values (Set).
  • ✓ Sorting: Automatic ordering (ASC/DESC).
Uniqueness Probability Analysis

Birthday Paradox Formula

P(n) ≈ 1 - e^(-n(n-1)/(2d))
  • n : Number of items generated
  • d : Range size (Max - Min)
import math

def collision_prob(n, d):
    exponent = - (n * (n - 1)) / (2 * d)
    return 1 - math.exp(exponent)
Matrix Mode (2D Datasets) DATA SCIENCE READY

Generate massive datasets up to 1,000,000 elements (1000x1000). Optimized memory-safe algorithms ensure browser stability even at high loads.

  • >> Export: JSON, CSV, Plain Text
  • >> Syntax: Custom Brackets [ ] & Commas
import pandas as pd
import json

# Load TRUERNG JSON export
with open('matrix.json') as f:
    data = json.load(f)

df = pd.DataFrame(data)
print(df.describe()) # Instant stats

Related Tools & Research

Advanced Configuration

While Basic Mode covers everyday needs, the Advanced Mode is a specialized engineering environment designed for cryptographic data generation and entropy masking. It allows developers to impose strict syntax rules on randomness, making it ideal for creating synthetic datasets, secure tokens, API keys, and deterministic identifiers compliant with specific database constraints.

Pattern Mask Engine

Define rigid structures for complex ID generation formats using our dynamic Pattern Mask Engine. By utilizing precise placeholders, you can construct unique identifiers, serial keys, and formatted strings that maintain high entropy while adhering to strict business logic and validation requirements.

{N}Digits (0-9)
{L}Upper (A-Z)
{l}Lower (a-z)
{H}Hex (0-F)
{S}Special (!@#)

Real-world Examples

MAC Address: {H}{H}:{H}{H}:{H}{H}:{H}{H}:{H}{H}:{H}{H}
UUID v4 (Pseudo): {H}{H}{H}{H}{H}{H}{H}{H}-{H}{H}{H}{H}...
Product SKU: PROD-{N}{N}{N}-{L}{L}
Temporary Password: {L}{l}{l}{N}{N}#{S}{L}
IPv6 Local: FE80:0000:0000:0000:{H}{H}{H}{H}...
Usage Note

These patterns demonstrate how to replicate standard networking and database formats. Use them for mocking API responses, testing regex validation fields, or generating bulk inventory codes without manual formatting.

Charset & Rules

Fine-tune your character set distribution for precise control over output strings. Whether you need password complexity compliance or specific alphanumeric balances, this tool offers granular settings for length-based entropy versus rule-based generation, ensuring resistance against basic dictionary attacks.

Total Length

Maximizes informational entropy by utilizing the full selected pool without artificial limits.

  • Perfect For:
  • • Session IDs
  • • CSRF Tokens
  • • Cryptographic Salts

Specific Counts

Enforces strict character quotas (e.g., 'must contain 2 specials') to meet security policies.

  • Perfect For:
  • • User Passwords
  • • License Codes
  • • Validation Tests
Note: Advanced mode fully supports No Repeats (guarantees unique strings in a list) and Sorting (lexicographical or length-based).

Deep Dives & Use Cases

Use Case: HEX Color Matrix

Generate color palettes for UI testing. Use custom patterns to test different channel configurations.

Standard HEX: #{H}{H}{H}{H}{H}{H}
Alpha HEX: #{H}x8
Short HEX: #{H}{H}{H} 
function hexToRgb(hex) {
  const bigint = parseInt(hex.slice(1), 16);
  const r = (bigint >> 16) & 255;
  const g = (bigint >> 8) & 255;
  const b = bigint & 255;
  return { r, g, b };
}

NFT Collection DNA Generation

Simulate blockchain-grade randomness for NFT Collections (ERC-721/1155). This visualizer demonstrates how Provable Fairness and CSPRNG algorithms generate unique metadata traits and DNA strings, ensuring unbiased rarity distribution for digital assets and immutable tokens.

Body Rig
COMPONENTS MASK
HEAD: ...
L-HAND: ...
L-LEG: ...
R-LEG: ...
R-HAND: ...
Face Rig
COMPONENTS MASK
HAIR: ...
L-EAR: ...
L-EYE: ...
NOSE: ...
MOUTH: ...
R-EYE: ...
R-EAR: ...

Real-world Examples

Bored Ape Style ↗ BAYC-{H}{H}{N}{N}
CryptoPunks ↗ PUNK#{N}{N}{N}{N}
Azuki Element ↗ ELEM-{L}{L}-{N}{N}
CloneX DNA ↗ CLX-{H}{H}{H}{H}-{L}
Doodles ↗ DOOD-{N}{N}-{H}{H}
Usage Note

These patterns demonstrate industry-standard metadata structures used in blue-chip NFT collections. Bored Ape (BAYC) utilizes a specific hex-numeric mix for provenance. CryptoPunks relies on a classic numeric identifier sequence. Azuki introduces element-based alphanumeric segmentation. CloneX employs complex hex strings for 3D asset mapping. Doodles uses a simplified numeric-hex hybrid for pastel trait generation. Use these templates to test smart contract compatibility, validate metadata JSON schemas, or simulate rarity sniping tools.

Privacy Note

Custom presets are saved directly to your browser's localStorage. They persist across sessions but are never sent to our servers.

Real-World Applications

Leverage the power of the Web Crypto API to generate high-entropy, cryptographically secure random values. Whether you are conducting Monte Carlo simulations, performing Fuzz Testing for QA automation, or securing sensitive data with CSPRNG-derived salts, TrueRNG provides the statistical independence and unpredictability required for enterprise-grade applications, scientific research, and complex stochastic modeling.

QA & DevOps

Unit Testing Fuzzing Edge Cases

Generate unpredictable strings and numerical arrays to validate input sanitization logic. Use the Pattern Mask Engine to create localized formats (ZIP codes, Phone numbers) for form validation or utilize Matrix Mode to produce massive datasets for stress testing database read/write operations.

Data Science

Monte Carlo AI Datasets A/B Testing

Create unbiased synthetic datasets for training Machine Learning models when real-world data is scarce. Use the List Generator to perform randomized control trials (A/B testing grouping) or introduce controlled 'white noise' into numerical sequences to test algorithm robustness against anomalies.

Game Dev

Loot Tables PCG Rarity

Design balanced loot systems using weighted probability simulation via our Advanced List Mode. Generate unique seeds for procedural map generation or create diverse NPC attributes using the Character Set Rules to ensure non-repetitive gameplay experiences.

Cybersecurity

CSPRNG Salts & IVs Air-gapped

Generate cryptographically secure nonces, salts, and initial vectors (IV) for encryption protocols. The client-side architecture allows for Air-gapped generation—you can disconnect the internet and generate high-entropy master passwords or API keys without any network exposure.

Education

Classroom Probability Fair Groups

Streamline classroom management by generating unbiased sequences for student presentations or creating fair subgroups for team projects using List Mode (No Repeats). Essential for math teachers demonstrating probability theory or shuffling exam variants to prevent cheating.

Daily Use

Decisions Lottery Passwords

From settling simple arguments to picking lucky lottery numbers. Use Single Mode as a fair arbiter for daily decisions ("Who buys coffee?"), generate secure passwords for personal accounts, or organize random gift exchanges (Secret Santa) without third-party apps.

Frequently Asked Questions

Is the generation truly random? How does it differ from Math.random()?
Yes. Unlike standard Math.random() which is a predictable PRNG (Pseudo-Random Number Generator), TrueRNG utilizes the Web Crypto API (crypto.getRandomValues). This leverages CSPRNG (Cryptographically Secure Pseudo-Random Number Generator) standards, pulling from your device's OS-level entropy pool (thermal noise, interrupts, I/O events) to ensure statistical unpredictability.
Is my data sent to a server? Can you see my passwords?
No. The architecture is 100% Client-Side. All code executes locally within your browser's sandbox. No data is transmitted via network requests, ensuring Zero-Knowledge privacy. You can even use this tool offline (Air-gapped) for maximum security when generating sensitive keys.
Can I use generated datasets for Mocking or Fuzz Testing?
Absolutely. Use Matrix Mode to generate large 2D arrays (up to 1M elements) and export them as JSON or CSV. These files can be directly ingested into test automation frameworks (Selenium, Cypress), Postman mock servers, or Data Science libraries (Pandas, NumPy) to validate input handling and boundary conditions.
Why can't I manually set a "Seed" for the generator?
Manual seeding is a feature of deterministic PRNGs (like Mersenne Twister). Since TrueRNG relies on non-deterministic hardware entropy provided by the browser's security stack, the initial state is constantly fluctuating. This guarantees forward and backward secrecy, essential for cryptographic operations like Salt or Nonce generation.
What are the generation limits? Can I crash my browser?
To protect your browser's memory, we limit single operations to 1,000,000 elements (e.g., a 1000x1000 Matrix). While the algorithm is highly optimized (utilizing TypedArrays), generating massive datasets entirely in the DOM can be resource-intensive. For larger datasets, we recommend generating in batches using List Mode.
Action Successful