How I Built an Infinite Retro Game Soundtrack Generator Using Quantum Physics and Gemini 2.5 Flash
We’ve all been there. You’re building an indie game, and you need background music. You don’t have the budget to license tracks, and you definitely don’t have the time to learn music theory.
So, I asked myself: Can I build a machine that generates infinite, royalty-free, copyright-cleared retro game music using Python?
The answer is yes. But to make it actually good, I had to do something a little crazy. I had to abandon standard computer randomness and use Quantum Vacuum Fluctuations and Google’s Gemini 2.5 Flash.
Here is how I built the Quantum Retro Composer.
The Problem with random.randint()
My first attempt was simple: use Python’s random library to pick notes from a scale.
# The "Robot Chaos" approach note = random.choice(['C', 'E', 'G', 'B'])
The result? It sounded like a robot falling down the stairs. It was random, but it wasn't music. Music isn't just random events; it's structure, repetition, and "vibe." Standard pseudo-random number generators (PRNGs) are deterministic and boring. They don't have souls.
To fix this, I needed two things:
- True Entropy: Randomness derived from the physical world, not an algorithm.
- Musical Intelligence: Something that understands the difference between a "boss fight" and a "stealth mission."
Step 1: Harvesting Entropy from the Vacuum
To get "organic" variation, I connected my Python script to the Australian National University (ANU) Quantum Random Numbers API.
This API measures the quantum fluctuations of the vacuum in real-time. By measuring the noise of a laser, we get true, unpredictable entropy. I combined this with my computer's hardware entropy and the current nanosecond time to generate a Cryptographic Seed.
def get_quantum_seed(): # 1. Get Hardware Entropy hw = secrets.token_bytes(32) # 2. Get Quantum Vacuum Data (from ANU API) qw = requests.get("https://qrng.anu.edu.au/API/jsonI.php...").content # 3. Hash them together hasher = hashlib.sha256() hasher.update(hw + qw) return int(hasher.hexdigest(), 16)
Now, every song my script generates is mathematically unique in the universe.
Step 2: The Conductor (Gemini 2.5 Flash)
Randomness gives us variation, but it doesn't give us structure. This is where Gemini 2.5 Flash comes in.
Instead of writing complex rules for music theory (which is hard), I treat the LLM as a "Composer." I feed it my Quantum Seed and a prompt describing the vibe I want ("High energy retro game boss fight"), and I ask it to return a JSON "Music Sheet."
Here is the secret sauce: I don't ask Gemini for audio. I ask for Data.
prompt = f""" You are a legendary Retro Game Composer. Seed: {seed}. Create a BUSY, CONTINUOUS Retro Game Soundtrack (3 Phases). JSON Structure: {{ "bpm": 125, "phase_1": {{ "kick": [0, 4, 8...], "bass": [ {{ "step": 0, "freq": 55.0 }} ] }}, "phase_2": {{ ... }} }} """
Gemini understands syncopation. It knows that if the kick drum hits on beat 1, the snare usually hits on beat 2. It handles the "music theory" so I don't have to.
Step 3: The Synthesizer (Pure Math)
I didn't want to rely on external sample packs (MP3s) because that limits variation. Instead, I built a Digital Signal Processing (DSP) engine in Python using numpy.
Every instrument is generated from scratch using sine waves, noise, and math.
The "Retro" Kick Drum: To sound like a 90s console, you don't use a real drum recording. You take a sine wave and pitch-shift it down rapidly.
def synth_kick_retro(): t = np.linspace(0, 0.4, int(44100 * 0.4)) # Drop pitch from 150Hz to 40Hz quickly freq = 150 * np.exp(-12 * t) + 40 wave = np.sin(2 * np.pi * freq * t) # Clip it for that "crunchy" 16-bit sound return np.clip(wave * 1.5, -0.8, 0.8)
I built similar mathematical models for:
- Snare: White noise + a short sine wave "thud."
- Bass: A square wave (NES style).
- Keys: Pulse waves with a simple LFO (Low Frequency Oscillator) for tremolo.
Step 4: The "Glue" (Solving the Silence)
The early versions of the script had a flaw: they were too sparse. The AI would write a cool beat for 2 seconds and then leave 2 seconds of silence. It sounded like a ticker tape.
To solve this, I wrote a Density Enforcer.
Before rendering the audio, my script scans the JSON returned by Gemini. If the drum pattern is too empty, or if the loop doesn't extend to the end of the bar, the Python script mechanically injects "filler" notes—like a steady hi-hat or a drone pad—to ensure there is never dead air.
def ensure_density(data): # If the AI forgot to write Hi-Hats, force 8th notes if len(data.get("closed_hat", [])) < 16: data["closed_hat"] = list(range(0, 64, 2)) return data
I also added a Pad Drone—a low-volume background synthesizer that plays the root note continuously. This acts as "audio glue," blending the disjointed AI notes into a cohesive track.
The Result: Infinite Retro Bops
The final script exports a .wav file that is:
- Seamlessly Looping: It calculates the exact sample count to cut the file on the beat.
- Bit-Crushed: I added a downsampling algorithm to emulate the SNES audio chip.
- Copyright Free: Generated by math + entropy.
I can now generate a unique, 3-minute evolving boss theme in about 15 seconds. It starts with a stealthy intro, builds into a groove, hits a chaotic climax, and fades back out—all dictated by the roll of a quantum dice.
Check it out on GitHub
This project was completed by Gemini in the browser. Visual Studio Code was used for testing. As always, I am a very blind individual, and I use special tools to help me do my projects. Centaur Model ftw! (for the win)
You May Also Like
The Role of Blockchain in Building Safer Web3 Gaming Ecosystems
- Immutable Ownership of Assets Blockchain records can be manipulated by anyone. If a player owns a sword, skin, or plot of land as an NFT, it is verifiably in their ownership, and it cannot be altered or deleted by the developer or even hacked. This has created a proven track record of ownership, providing control back to the players, unlike any centralised gaming platform where assets can be revoked.
- Decentralized Infrastructure Blockchain networks also have a distributed architecture where game data is stored in a worldwide network of nodes, making them much less susceptible to centralised points of failure and attacks. This decentralised approach makes it exponentially more difficult to hijack systems or even shut off the game’s economy.
- Secure Transactions with Cryptography Whether a player buys an NFT or trades their in-game tokens for other items or tokens, the transactions are enforced by cryptographic algorithms, ensuring secure, verifiable, and irreversible transactions and eliminating the risks of double-spending or fraudulent trades.
- Smart Contract Automation Smart contracts automate the enforcement of game rules and players’ economic exchanges for the developer, eliminating the need for intermediaries or middlemen, and trust for the developer. For example, if a player completes a quest that promises a reward, the smart contract will execute and distribute what was promised.
- Anti-Cheating and Fair Gameplay The naturally transparent nature of blockchain makes it extremely simple for anyone to examine a specific instance of gameplay and verify the economic outcomes from that play. Furthermore, multi-player games that enforce smart contracts on things like loot sharing or win sharing can automate and measure trustlessness and avoid cheating, manipulations, and fraud by developers.
- Cross-Platform Security Many Web3 games feature asset interoperability across platforms. This interoperability is made viable by blockchain, which guarantees ownership is maintained whenever assets transition from one game or marketplace to another, thereby offering protection to players who rely on transfers for security against fraud. Key Security Dangers in Web3 Gaming Although blockchain provides sound first principles of security, the Web3 gaming ecosystem is susceptible to threats. Some of the most serious threats include:
Fintech Is Leveling the Playing Field in Trading, Says Zak Westphal
