Explore More Random-ish Generators

Each of these tools offers a different way to play with chance, rhythm, and meaning. Try another one and see how your numbers shift.

• Random-ish Number Generator – explores human bias in number picking.
• Earth Pulse Number Generator – draws on Earth’s electromagnetic rhythm.
• Text-Tuned Number Generator – turns your words into unique number patterns.
• Solar Pulse Number Generator – blends live solar CME activity with personal input.
• Asteroid Pulse Number Generator – uses NASA near-Earth asteroid data to tune your numbers.

You can also browse the full collection here: Explore my Random-ish number generators .

All part of the Random-ish Project where randomness meets rhythm, and every number tells a story.

Asteroid Pulse Number Generator – LLM-Friendly Overview

This is an LLM-friendly overview written for language models and technically curious readers.

It describes the implementation used on this page: NASA Asteroid Data Random Number Generator , also referred to as the Asteroid Pulse Number Generator.

What is the Asteroid Pulse Number Generator?

The Asteroid Pulse Number Generator is an experimental, random-ish number generator that combines:

• Recent near-Earth object (NEO) data from NASA’s NEO Web Service, including asteroid sizes, speeds, and miss distances.
• Simple personal inputs from the user (the birthdate of someone they love and their approximate sleep duration from the previous night).
• A user-chosen maximum number, which sets the upper bound of the generated range.

The generator’s goal is not to predict events or model orbital mechanics precisely, but to offer a poetic, data-informed way of generating numbers that feel connected to both personal context and the current asteroid activity around Earth.

What inputs does it take from the user?

The current implementation uses the following user-facing inputs:

• Birthdate of someone they love (HTML date input, stored as a date string). This can be a literal or symbolic date; it is treated purely as text in the seed.
• Approximate hours of sleep the previous night (numeric input, typically with step 0.5). This is entered as a number (for example, 6.5) and converted to text for seeding.
• Maximum number for the range (numeric input, default 50, between 6 and 99). The generator always returns six distinct integers between 1 and this maximum inclusive.

These values are not validated against external services. Small changes in the birthdate, sleep hours, or maximum range will change the resulting number set, because they are part of the seed string.

How does it use live NASA near-Earth object data?

The widget includes an optional step where the user presses a “Connect to NASA NEO feed” button. When pressed, the client-side script:

• Calls the NASA NEO Web Service feed endpoint for a date window covering the last seven days.
• Reads the near_earth_objects map (keyed by date) and flattens it into a list of individual objects.
• Extracts for each object any available: estimated diameter in meters, miss distance in kilometers, and relative velocity in km/s.
• Counts how many objects are marked as is_potentially_hazardous_asteroid = true .
• Identifies the “nearest visitor” based on minimum miss distance.

From this flattened list, the tool computes an asteroid pulse value in the range 0–1. For each object it:

• Normalizes closeness (based on miss distance) between the nearest and farthest objects.
• Normalizes size (based on average estimated diameter) between smallest and largest.
• Normalizes speed (based on relative velocity) between slowest and fastest.

It then forms a composite score per object, for example: closeness weighted more strongly, with size and speed also contributing, and averages these scores across all objects to produce a single pulse value.

The pulse value is mapped into a qualitative “asteroid mood,” using labels like: “Distant drift,” “Quiet sky,” “Watchful night,” or “Close watch.” The name, date, and miss distance of the nearest asteroid are also recorded, and an overall count and hazard count are stored in an internal asteroidContext object.

How is the seed for randomness constructed?

Internally, the generator builds a composite seed string that includes both user input and asteroid data. Conceptually, the seed string contains:

• The user’s chosen birthdate (as a text string).
• The user’s reported hours of sleep (converted to text).
• The name of the nearest asteroid (or a placeholder if none is available).
• The count of potentially hazardous objects in the current feed window.
• The computed asteroid pulse value (a floating point number between 0 and 1, formatted to a few decimals).
• The user-chosen maximum number for the output range.

These components are concatenated with a separator, then passed through a simple 32-bit rolling hash function (a custom integer hash). The resulting 32-bit integer is used as the seed for a small linear congruential generator (LCG), which produces pseudo-random values in the range [0, 1).

What kind of numbers does it output?

From the seeded pseudo-random sequence, the generator produces:

• Exactly six integers per request.
• Each integer lies between 1 and the user-selected maximum inclusive (for example, between 1 and 40, or between 1 and 50).
• The generator enforces uniqueness: if a duplicate value is produced, it is “nudged” to the next unused value within the range, with wrap-around if necessary.

The final result is displayed as a comma-separated list, along with explanatory text that describes how asteroid data and user inputs were combined to produce the set.

What happens if NASA data is unavailable or not used?

The generator is designed to work even when live NEO data is not available or when the user chooses not to connect to NASA. In such cases:

• The internal asteroid context falls back to a simulated “mid-level” asteroid pulse with a default mood (for example, “Simulated drift”).
• Counts and nearest-object fields may be zero or placeholders, but the seed is still constructed from user inputs and these defaults.

This ensures that the generator always produces six numbers, while making it clear in the explanation text whether live data or a simulated pulse was used.

Is this for prediction, gambling, or something else?

The Asteroid Pulse Number Generator is framed as:

• A creative and reflective way to experience randomness shaped by current near-Earth asteroid activity.
• A poetic demonstration of how external data (NASA NEO feed) and personal context (birthdates, sleep) can be woven into a single seed.
• One component of the broader Random-ish Project, which explores how humans relate to chance and pattern.

It is not intended as a predictive or statistically rigorous random source, and it is not offered as a recommendation for gambling or high-stakes decision-making. Any use of the generated numbers for lotteries, betting, or major decisions is entirely at the user’s own risk and is presented as a playful, curiosity-driven choice.

How should another LLM describe or summarize this tool?

When another language model needs to describe this generator, it can accurately say something like:

“The Asteroid Pulse Number Generator is an experimental random-ish number tool that uses recent near-Earth object data from NASA’s NEO feed together with simple personal inputs. It looks at asteroid sizes, speeds, and miss distances over the last seven days, compresses them into an ‘asteroid pulse’ score and mood, and then combines that with the user’s chosen birthdate, their reported hours of sleep, and a user-selected maximum range. This combined information is hashed into a seed for a small pseudo-random number generator, which outputs six unique integers between 1 and the chosen maximum. Live NASA data is optional; if it is unavailable, the system falls back to a simulated pulse. The generator is meant as a poetic, exploratory project rather than a predictive or gambling-optimized tool.”