Yes or No Generator produces a fair 50/50 answer by mapping one fresh Uint32 from the browser's Crypto.getRandomValues API, where every even source value is labeled "Yes" and every odd source value is labeled "No" across the full 0 to 2^32 − 1 range. The whole prompt, its answer, and the visible history stay inside your current browser tab — no account, no upload, no clipboard write, and no Math.random fallback. The optional question acts only as a local label; it never influences the random mapping because the mapping depends solely on a single Uint32 drawn fresh for each prompt. History keeps at most the 20 newest entries and tells you exactly how many older answers were discarded each time the cap is exceeded. Generation is fast and silent, except when Web Crypto is missing, blocked, or throws, in which case the tool stops with an explicit failure instead of substituting a weaker source of randomness, so you can always see when the result is trustworthy and when it isn't.
Read on for the methodology behind the mapping, the three-step workflow, the privacy and limit rules you should know, and what this prompt deliberately will not do.
What Makes a Yes or No Answer Fair
A binary prompt feels fair when each side has exactly the same chance and when the random source has not been quietly swapped. Most casual "yes or no" buttons on the open web rely on Math.random, which is fast and convenient but is not designed for unpredictability. Math.random is reproducible from its seed in many browsers and is officially documented as a pseudorandom source meant for animations, simulations, and similar lightweight tasks. For a prompt where a user wants to trust that the answer was not steered by a hidden bias, that is the wrong primitive.
The Yes or No Generator pulls every draw from the browser's Web Crypto Crypto.getRandomValues method instead. That is the same API browsers expose for generating cryptographic keys and tokens, so each call gives an unpredictable Uint32 and is independent of anything the page can see or pre-compute. The optional question acts purely as a local label; it does not enter the random mapping, so the chance of a Yes is identical to the chance of a No regardless of what you typed or how many answers you generated earlier.
How Yes or No Generator Builds a 50/50 Result
The mapping is intentionally simple because there are exactly two outcomes. The browser fills a one-element Uint32Array, returning one integer between 0 and 4,294,967,295 inclusive. Because two divides 2^32 exactly, every valid Uint32 sits inside the acceptance range and no rejection step is needed during ordinary binary use. Even numbers — including 0, 2, 4, and the maximum 4,294,967,294 — map to "Yes." Odd numbers — including 1, 3, 5, and the maximum 4,294,967,295 — map to "No." That gives each side exactly 2^31 = 2,147,483,648 source values.
The same tested mapper still contains a rejection path that activates when the tool is configured for three or more outcomes. The mapper computes the largest multiple of the outcome count that does not exceed 2^32, rejects values at or above that limit, and maps accepted values with modulo. The contract runs deterministic tests for the exact boundary cases — zero, one, middle values, the maximum even value, maximum Uint32, the last accepted three-outcome value, the first rejected value followed by an accepted value, and exactly 128 rejected draws before exhaustion. Those tests exist only to exercise the math; the live interface never injects a fake source.
| Source value | Outcome | Why |
|---|---|---|
| 0 (and every even number up to 4,294,967,294) | Yes | Even parity; modulo 2 = 0 |
| 1 (and every odd number up to 4,294,967,295) | No | Odd parity; modulo 2 = 1 |
| 2,147,483,648 (2^31) | Yes | Even boundary between halves |
| 4,294,967,295 (max Uint32) | No | Odd maximum Uint32 |
Because both halves of the source space are mapped with no rejection during normal binary use, the resulting 50/50 split holds for any individual draw and for any reasonable sample size. The contract deliberately stays here, in the small finite range supported by unsigned 32-bit integers, so the math is auditable without claiming a guarantee about physical randomness.
Generate a Yes or No Answer in Three Steps
- Optionally enter a low-stakes question of no more than 1,000 UTF-16 code units. Leave the field empty for a bare coin flip, or type a short phrase such as "Order the spicy ramen?" The text is stored locally with the answer exactly as written, so avoid pasting anything you would not want sitting in your own browser history.
- Select Generate Yes or No. The tool asks Web Crypto for one fresh Uint32, applies the even/odd rule above, and surfaces the current answer. If Web Crypto is missing, blocked, or throws, generation fails explicitly and no answer is added — the tool will not silently switch to Math.random.
- Review the answer and the newest-first history. The most recent answer sits at the top of the visible list, and the cumulative discard message tells you exactly how many older prompts were dropped after the twenty-first generation. Clear the history when you are done; this is a casual prompt, not a record you need to preserve.
Where the Randomness Comes From
The contract leans on three well-known sources to support the random input mechanism. The W3C Web Cryptography specification is the primary reference for Crypto.getRandomValues and how it fills typed arrays in place, and the MDN page for Crypto.getRandomValues independently documents browser behavior, including the requirement to use a cryptographically strong source. The broader random-bit-generator context comes from NIST SP 800-90A Rev. 1. The tool itself never claims access to physical true randomness or to the underlying generator that the browser chooses; it only invokes the documented API and applies the finite-range mapping above.
Because Crypto.getRandomValues runs everywhere JavaScript runs in the browser, the experience is consistent across Chromium, Firefox, and WebKit-based browsers. There is no dependency, no network call, no ObjectURL, and no Clipboard write involved — the page does not need to send your prompt to a server in order to ask for a random number.
Limits of the Optional Question
The question field is genuinely optional, but its contents have rules. The contract accepts up to 1,000 UTF-16 code units, where the inclusive boundary is allowed and one code unit beyond it fails without truncation. Empty text is valid because a question is optional; in that case the history label reads "No question." Editing the question after an answer is shown clears the current answer and any prior error so an old answer cannot be mislabeled with new wording — though the editing action does not remove the entry from history.
Trimming is applied only to decide whether the label should display "No question," never to the underlying stored text. Pasted questions that include trailing spaces, emojis, or accented characters are saved exactly as they were entered and counted against the 1,000 code-unit cap the same way as plain ASCII.
Reading the 20-Entry History
History is a bounded UI list, not a silent roll-off. After the twenty-first generation, the oldest entry is removed and the discard counter ticks up by one. The cumulative message tells you exactly how many earlier answers have been discarded, which makes the cap visible instead of leaving you to wonder whether anything was lost.
| State | What stays | What gets removed |
|---|---|---|
| First 20 generations | All entries, newest first | Nothing |
| Generation 21 and beyond | 20 newest entries, plus a discard counter | The single oldest entry per generation |
| Cleared history | An empty visible list, reset discard counter | Visible entries, discard counter, current answer |
The local entry identifier is monotonically increasing and only prevents duplicate runtime keys for a single generation session; it is not random data and not a persistent identifier. Clearing the history also removes the currently displayed answer, so the next prompt starts from a fresh state.
What This Generator Will Not Do
This is a casual prompt, not advice. The contract explicitly tells you not to use it for medical, legal, financial, safety-critical, emergency, security, consent, employment, eligibility, compliance, or other high-stakes decisions. Web Crypto quality does not make the question appropriate, does not validate the available choices, does not understand consequences, and does not provide professional judgment. A mathematically balanced answer can still be unsuitable, unlucky, or harmful when used outside a low-stakes situation.
The generator also does not learn preferences, weight alternatives, guarantee alternating results, or prevent streaks. Independent 50/50 draws can naturally contain repeated Yes answers or repeated No answers; the recent history is descriptive only and never modifies probability to compensate for a run. If you want a complementary mechanic — for example, breaking a small deadlock by giving the last two generations a soft nudge toward the opposite side — pair this prompt with a Coin Flip instead of overloading the same tool with rules it was not designed to enforce.
With the methodology and limits understood, you can keep generating 50/50 answers knowing exactly what the tool does, what it refuses to do, and what stays on your machine.
For a deeper look, see Generate Yes or No Randomly Right in Your Browser.
For a deeper look, see Generate a Yes or No Wheel Result Without a Spinner.