A command-line number picker is a shell command or short script — typically shuf, $RANDOM, or a Python one-liner — that returns an integer from a chosen range without launching a graphical application; an online number picker is a browser-based tool that does the same job through form fields, with the actual random source either running locally in the page or living on a remote server. Both produce integers; the practical differences live in setup, reproducibility, fairness, and who can use the result without help. Command-line methods slot into scripts and pipelines, leave an audit trail in the terminal, and are reproducible when you control the seed, but they assume the operator has a shell, knows the syntax, and trusts the host's entropy pool. Online pickers trade that control for accessibility — anyone with a browser can use one — and the better ones run the random sampling entirely in JavaScript so no values leave the device. Choosing between them comes down to who is generating the number, whether the result needs to be reproducible later, and how much scripting you actually need.
Command-Line Ways to Pick a Random Number
The most common command-line approaches to picking a random integer are short enough to fit on one line. On Linux and macOS, the shell utility shuf accepts a range and an output count: shuf -i 1-100 -n 1 prints one integer between 1 and 100 inclusive, and shuf -i 1-100 -n 5 prints five. shuf uses the system's random source, so its quality depends on the operating system — on Linux it draws from /dev/urandom, which is suitable for general-purpose sampling but not for cryptographic keys.
Bash's built-in $RANDOM is even terser: echo $((RANDOM % 100 + 1)) returns an integer in 1–100. The modulo operator, however, introduces bias whenever the modulus does not divide the random output range evenly, and $RANDOM itself is a 15-bit generator that should not be used for anything consequential. Python is the most common escape hatch for a more disciplined draw:
python -c "import random; print(random.randint(1, 100))"
This calls the Mersenne Twister implementation in the standard library, which is fast and reproducible when you set a seed, but is also not a cryptographically secure generator. For sensitive contexts, Python's secrets module is the appropriate choice:
python -c "import secrets; print(secrets.SystemRandom().randint(1, 100))"
Node, PowerShell, awk, and even /dev/urandom piped through od all offer variants of the same idea. The unifying strengths are scriptability — every command can be embedded in a cron job, a Makefile target, or a CI step — and reproducibility, because most of these tools accept an explicit seed or rely on the same system entropy every run. For a fuller Python-focused walkthrough, see the How to Generate Random Numbers in Python (No Code) guide.
What Online Number Pickers Actually Do
An online number picker is, at minimum, a web page with two input fields and a button. A user types a minimum, types a maximum, optionally picks a count, and reads back a result. The user-visible behavior mirrors a one-line shell command, but the implementation path forks in two important directions: the random sampling either runs in the user's browser using JavaScript, or it runs on a server that the page calls behind the scenes.
The first approach is genuinely local. A browser-based generator that uses Lizely's Random Number Generator, for example, draws its random bits from the W3C Web Crypto interface and performs the range mapping inside the page. The bounds and the resulting numbers never travel over the network, which means there is no server-side log of what was generated, no account to tie the result to, and no requirement that you trust a remote service to be honest about its randomness.
The second approach — server-side — is what most casual "random number" websites do. The form submits, the server picks a number, and the response is rendered. That model is convenient for the operator (they can log draws, store seeds, or attach the result to a user account), but it changes the privacy story entirely: the bounds, the result, the IP address, and the timestamp are all visible to whoever runs the service. For classroom use, giveaways, or quick decisions, that may be irrelevant; for anything sensitive, it is not.
Command Line vs Online: A Side-by-Side Comparison
| Dimension | Command-line pickers (shuf, $RANDOM, Python) | Browser-based online pickers |
|---|---|---|
| Setup cost | None on most Linux and macOS systems; Python needs an interpreter | None — needs only a browser |
| Skill required | Comfort with a shell and the relevant syntax | Typing two numbers and clicking a button |
| Reproducibility | Possible by setting an explicit seed (Python) or saving the command | Limited — most pages do not expose a seed |
| Scriptable / embeddable | Yes — fits into any pipeline or cron job | No — results must be copied out by hand |
| Random source | System entropy (/dev/urandom) or library RNG | Browser Web Crypto, or a remote server if not local |
| Privacy of bounds and result | Stays on the host unless output is logged or uploaded | Depends: local if computed in-browser, sent to server otherwise |
| Range limits | Limited by the tool — shuf handles billions, $RANDOM caps at 32767 | Usually capped at safe-integer bounds and 1,000 results per call |
| Best for | Automation, batch jobs, reproducible experiments | One-off draws, non-technical users, classroom use |
The dimensions that most often decide the question are setup cost, who will actually run the draw, and whether the result needs to be reproducible later. If the answer to the last question is yes, a command-line tool with an explicit seed is almost always easier to defend than a browser page that does not expose one.
How to Pick a Range Online with the Random Number Generator
- Open the Random Number Generator in your browser and enter the smallest allowed integer in the minimum field.
- Enter the largest allowed integer in the maximum field. Both endpoints are eligible results, so a 1-to-10 range can produce 1 or 10 as easily as any number in between. Negative bounds are allowed, and a one-value range always returns that value.
- Choose how many integers you want, from 1 to 1,000, and decide whether duplicates are allowed. Leave duplicates on for independent draws — useful for repeated simulations or events where an earlier result should remain eligible. Turn duplicates off when you need distinct positions, identifiers, or numbered participants.
- Select Generate numbers. The page draws random bits from the browser Web Crypto interface and maps them into your inclusive range using rejection sampling, so each integer in the range receives the same number of possible accepted raw values.
- Review the comma-separated output. If the requested count of unique values exceeds the size of the range, the page reports that the request is impossible instead of retrying indefinitely or silently returning fewer numbers.
- Select and copy the result list. Changing any input clears the previous list, so an old result is not mistaken for output produced by new settings.
A worked example: with bounds 1 and 100, a count of 4, and duplicates disabled, the generator returns four distinct integers from 1 to 100, for example 17, 42, 88, 5. With duplicates enabled, the same bounds and count produce four independent integers from the same range, which can include repeats such as 17, 42, 17, 5. The exact numbers change every run; what does not change is that each accepted raw value has equal probability of mapping to any integer in the inclusive range.
When the Command Line Is the Better Choice
The command line wins whenever the draw has to slot into a larger workflow. A nightly cron job that picks five rows from a database for review, a Makefile target that randomizes the order of test fixtures, or a CI pipeline that fuzzes an input file with a fresh seed on every commit — all of these are easier to express as a one-line script than as a click on a web page. Reproducibility is the deciding factor in scientific and engineering work: Python's random.seed(42) followed by random.randint(...) produces the same integer on every run, and that property is what makes an experiment auditable. A browser page that does not expose its seed cannot offer the same guarantee.
Command-line pickers also handle ranges that exceed what a browser can represent exactly. shuf -i 1-1000000000 -n 1 works on any modern system; a JavaScript-based page is limited to safe-integer bounds, which top out at 9,007,199,254,740,991. For cryptographic or auditing needs, neither a shell utility nor a browser page is sufficient on its own — but a shell can be paired with openssl rand or getrandom(2), while a browser page cannot reach those primitives.
When an Online Number Picker Is the Better Choice
An online number picker removes every barrier between the user and the result. A teacher running a classroom draw, a parent picking a chore from a hat, or a small-business owner choosing a giveaway winner does not need a shell, an interpreter, or a script — they need a number. For these one-off cases, the right tool is whichever one the operator can actually run without making a mistake under pressure.
Browser-based generators also help when the person who needs the number is not the same person who will verify it later. A volunteer committee picking ticket winners, for example, can all use the same page on their own devices, see the same inclusive behavior, and copy the result into a shared document. The reproducibility story is weaker than a seeded script, but the audit story is stronger than a verbal agreement, because the tool's behavior — bounds, count, duplicates allowed or not — is visible in the form fields.
Privacy is the second axis. A local browser tool, like the Random Number Generator, does not send bounds or results to a server, so there is no log to subpoena and no third party to trust. A command-line tool has the same property by default — the number never leaves the host unless you pipe it somewhere — but a server-based online picker does not.
Fairness, Privacy, and the Audit Trail
Both approaches depend on the quality of the underlying random source. shuf on Linux reads from /dev/urandom, which is suitable for general sampling but is not the right primitive for key generation. Python's random module uses the Mersenne Twister, which is fast and statistically good but predictable from enough observed output. $RANDOM is a 15-bit linear congruential generator that fails basic statistical tests and should not be used outside scratch work. The browser Web Crypto interface, by contrast, is documented as a cryptographically strong source (see the MDN reference for Crypto.getRandomValues), and a well-implemented page that uses it with rejection sampling can map those bits into an inclusive range without modulo bias.
No general-purpose online or command-line tool is appropriate for regulated prize drawings, gambling, access control, password generation, or any other consequential decision. The Random Number Generator, like shuf and Python's random, runs without a signed audit trail, an external randomness beacon, or a reproducible transcript — there is no way for a visitor to prove later which browser entropy produced a particular list. For those decisions, follow the rules and independently audited procedures required by your organization, which typically involve witnessed draws, multiple independent sources of entropy, and a signed record.
For everyday tasks — classroom activities, drawings, randomized test data, order selection, game setup, and ordinary decisions that need unpredictable whole numbers — both command-line and browser-based tools are sufficient. The deciding questions are who will run the draw, whether the result must be reproducible later, and whether the bounds or result can leave the device. When the answer to that last question is no, a local browser tool is the cleanest fit.
For a deeper look, see LED Scroller Bulk Prep: One-Line Banners Without an App.