About

Generating uniformly distributed random times is less trivial than it appears. A naive approach using separate random calls for hours, minutes, and seconds produces skewed distributions when constrained to a sub-range. This tool maps the entire valid time span to a linear range of total seconds (or milliseconds), generates a single cryptographically secure random offset via crypto.getRandomValues(), then decomposes the result back into h, m, s, and ms components. This guarantees uniform probability across every representable instant within your specified window.

Common applications include test-data seeding for scheduling software, randomized exam or quiz timing, Monte Carlo simulations of arrival processes, and fair assignment of time slots. The generator supports both 12-hour and 24-hour formats, optional seconds and milliseconds precision, uniqueness constraints, and batch output up to 1000 values. Note: when uniqueness is enabled with millisecond precision disabled, the pool is limited to 86,400 distinct values per day. Requesting more unique times than the pool size will be capped automatically.

Formulas

The generator converts the user-defined time range into a linear integer domain, samples uniformly, then maps back to time components.

T_total = t_max − t_min

r = cryptoRand(0, T_total)

t = t_min + r

Decomposition from total seconds t:

h = floor(t ÷ 3600)

m = floor((t − h × 3600) ÷ 60)

s = t − h × 3600 − m × 60

When millisecond precision is enabled, the domain expands to total milliseconds (T_total × 1000), and ms = t mod 1000. The cryptographic random integer is generated via crypto.getRandomValues() with rejection sampling to eliminate modulo bias: a 32-bit unsigned integer is drawn, and values exceeding the largest multiple of T_total that fits in 2³² are discarded and redrawn.

Where t_min = start of range in seconds (or ms), t_max = end of range, r = uniform random offset, h = hours, m = minutes, s = seconds, ms = milliseconds.

Reference Data

Preset	Range	Format	Use Case
Full Day	00:00 - 23:59	24h	General purpose, simulations
Business Hours	09:00 - 17:00	24h	Office scheduling, meetings
Morning	06:00 - 11:59	12h	Alarm testing, wake-up routines
Afternoon	12:00 - 17:59	12h	Appointment slots
Evening	18:00 - 22:59	24h	Event scheduling, dinner reservations
Night Shift	22:00 - 05:59	24h	Shift rotation, security patrols
School Hours	08:00 - 15:00	12h	Class scheduling, bell times
Lunch Window	11:30 - 13:30	12h	Break assignment, restaurant sims
Peak Traffic	07:00 - 09:00	24h	Traffic simulation, load testing
Late Night	23:00 - 03:59	24h	Nightlife, server maintenance windows
Exact Noon ±1h	11:00 - 13:00	24h	Solar studies, shadow calculations
Dawn	04:30 - 06:30	24h	Photography, astronomy
Dusk	17:30 - 20:30	24h	Sunset events, lighting tests
Full Day (ms)	00:00:00.000 - 23:59:59.999	24h	High-precision test data

Frequently Asked Questions

The entire range is linearized into total seconds (or milliseconds). A single cryptographically secure random integer is drawn from [0, range_size) using rejection sampling to avoid modulo bias. This integer is then added to the range minimum and decomposed into h:m:s:ms. Because the sampling is uniform over a contiguous integer domain, every representable instant within the range has equal probability.

The generator interprets this as a range that wraps past midnight. Internally, it calculates the span as (24:00:00 minus start) plus (end minus 00:00:00). The random offset is computed over this combined span, and if the resulting time exceeds 23:59:59, it wraps around by subtracting 24 hours. This correctly models overnight shifts, late-night windows, and cross-midnight scenarios.

Without milliseconds, the pool is the number of distinct seconds in the range. For a full 24-hour day that is 86,400 unique values. With milliseconds enabled, it becomes 86,400,000. If you request more unique times than the pool contains, the generator automatically caps the count at pool size and notifies you. Attempting to generate 1,000 unique times within a 10-minute window (600 seconds) will succeed, but requesting 700 unique times within the same range without milliseconds will be capped to 600.

Math.random() uses a PRNG (typically xorshift128+) that is fast but not cryptographically secure and can exhibit subtle patterns over large sample sizes. crypto.getRandomValues() draws from the operating system's entropy pool (e.g., /dev/urandom on Linux, CryptGenRandom on Windows), providing true uniformity suitable for security-sensitive applications, fair lottery systems, and statistically rigorous simulations.

Yes. The tool provides a sort toggle (ascending or descending by time value) and a Copy All button that places all generated times onto the clipboard as newline-separated text, ready for pasting into spreadsheets, databases, or code. Individual times can also be copied by clicking them.

The generator follows the convention where 12:00:00 is 12:00 PM (noon) and 00:00:00 (midnight) is displayed as 12:00 AM. Times from 00:01 to 11:59 receive the AM suffix, and 12:01 to 23:59 map to 12:01 PM through 11:59 PM. This matches the ISO 8601-adjacent convention used in the United States and is unambiguous in the output.