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
Shannon Entropy Formula
- 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
import java.security.SecureRandom; SecureRandom random = new SecureRandom(); byte[] values = new byte[20]; random.nextBytes(values); // Uses /dev/urandom logic
#include <random> #include <iostream> std::random_device rd; std::mt19937 gen(rd()); std::uniform_int_distribution<> dis(1, 100); // rd() provides non-deterministic entropy
// Web Crypto API (Client-Side)
const array = new Uint32Array(1);
self.crypto.getRandomValues(array);
console.log("Secure Random:", array[0]);
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.
- ● 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.
- ✓ No Repeats: Guarantees unique values (Set).
- ✓ Sorting: Automatic ordering (ASC/DESC).
Birthday Paradox Formula
- 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)
public double collisionProb(double n, double d) {
double exponent = - (n * (n - 1)) / (2 * d);
return 1 - Math.exp(exponent);
}
#include <cmath>
double collisionProb(double n, double d) {
double exponent = - (n * (n - 1)) / (2 * d);
return 1 - std::exp(exponent);
}
function collisionProb(n, d) {
const exponent = - (n * (n - 1)) / (2 * d);
return 1 - Math.exp(exponent);
}
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.
Real-world Examples
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
Deep Dives & Use Cases
Generate color palettes for UI testing. Use custom patterns to test different channel configurations.
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 };
}
def hex_to_rgb(hex_val):
hex_val = hex_val.lstrip('#')
return tuple(int(hex_val[i:i+2], 16) for i in (0, 2, 4))
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.
Real-world Examples
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.
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
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
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
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
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
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
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()?
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.