I generated 100 artworks from real quantum measurements: what happened

Every generative art project you've seen uses pseudorandom numbers. Algorithms that look random but aren't — deterministic sequences that a sufficiently motivated person could predict and reconstruct.

I wanted something different. I wanted art generated from real quantum measurements: outcomes that are fundamentally unpredictable, not just practically unpredictable. Outcomes that did not exist until the moment a qubit was measured.

So I connected to two real quantum computers — Origin Quantum's WK_C180 (180 qubits) and IBM Quantum's ibm_fez (156 qubits) — and used their measurement outputs to make 100 unique pieces. No simulators, no classical fallbacks. Every pixel trace traces back to an actual quantum measurement that didn't exist until the circuit ran. This is the story of that run.

Why quantum randomness matters for art

When you call Math.random() in JavaScript, you get a number from a deterministic algorithm. Same internal state, same output, always. Pseudorandomness — plenty for most things, but fundamentally predictable.

Quantum randomness operates at a different level. Put a qubit in superposition with a Hadamard gate and measure it, and the 0-or-1 outcome is governed by the Born rule of quantum mechanics. No hidden variable decides it, no algorithm produces it. It simply happens.

For art, that means each piece is anchored in an event that is literally non-reproducible. You can't rewind the universe and get the same measurement twice. The pieces inherit that.

The pipeline, from qubit to pixel

Here's the complete chain, and each step ran the same way for every piece:

  1. Quantum circuit: a 12-qubit circuit applies Hadamard gates (superposition) and CNOT gates (entanglement) to create a maximum-entropy state.
  2. Measurement: the circuit runs on real hardware — 8,000 shots on Origin Quantum, 4,096 on IBM Quantum. The measurement distribution is the raw data.
  3. Quantum seed: the distribution is hashed through SHA-256 into a 256-bit hex seed, e.g. 2cf1b4034f223f5c3e6a83019656e65597828ae375db07b2ef358ac523dde706.
  4. Deterministic RNG: the seed initializes a custom QuantumRNG class (xorshift128+ style, expanded from SHA-512) that produces a reproducible stream of values.
  5. SVG generation: the RNG stream drives every visual decision — circles, rectangles, ellipses, bezier curves, polygons, gradients, and color harmonies (complementary, analogous, triadic, split-complementary, tetradic).
  6. PNG conversion: SVGs are rasterized to PNG.
  7. IPFS upload: art and metadata are pinned to IPFS via Pinata.
  8. Polygon mint: each NFT mints on Polygon mainnet as an ERC-721 token with 5% EIP-2981 royalties.

The neat part: once you have the quantum seed, the art is fully deterministic. Same seed, same image, always — you can regenerate any piece from its seed. But the seed itself came from quantum physics, and it can never be reproduced.

What the art looked like

Three pieces from the collection, each tracing back to a unique measurement:

Quantum Genesis #1 — Origin Quantum WK_C180

Quantum Genesis #1 — Origin Quantum WK_C180

Quantum Genesis #25 — IBM Quantum ibm_fez

Quantum Genesis #25 — IBM Quantum ibm_fez

Quantum Genesis #75 — IBM Quantum ibm_torino

Quantum Genesis #75 — IBM Quantum ibm_torino

Each NFT carries on-chain metadata: Entropy Level, Entropy Score (0-100), Qubit Configuration (GHZ-3, Steane-7, and more), Quantum Phase (Interfering, Superposition, etc.), Color Harmony, and Complexity Score.

The Origin Quantum chapter (NFTs #1-18)

The project began at Origin Quantum, a Chinese quantum computing company. Their WK_C180 chip — 180 superconducting qubits — is accessed through the pyqpanda3 SDK via their QCloudService API.

Each circuit ran 8,000 shots. The first 18 NFTs came out of this. Getting access, debugging the SDK, and reverse-engineering the correct measurement syntax (measure([0,1], [0,1]) with explicit classical bits) was an entire adventure of its own.

Those 18 pieces carry a provenance I couldn't have engineered: they're among the very few NFTs ever minted from a Chinese quantum processor.

The IBM Quantum chapter (NFTs #19-100)

For the remaining 82, I moved to IBM Quantum. Using Qiskit Runtime's SamplerV2, circuits ran on ibm_fez (156 qubits) and ibm_torino (133 qubits), 4,096 shots each.

IBM's infrastructure was steadier for batch work. Each NFT took roughly 19 seconds on ibm_fez. Transpilation used generate_preset_pass_manager at optimization level 1 to map the 12-qubit circuit onto each processor's physical topology.

The whole batch — generate, convert to PNG, upload to IPFS, mint — completed with zero classical fallback. Every one of those 82 seeds is verifiably quantum.

100 pieces, zero classical fallback

What the finished collection amounts to:

  • 100 unique NFTs on Polygon mainnet (ERC-721, contract 0x488f...1a27)
  • Two quantum processors: Origin Quantum WK_C180 + IBM Quantum ibm_fez/ibm_torino
  • All art on IPFS: immutable, decentralized storage via Pinata
  • 5% royalties via EIP-2981
  • Zero classical fallback — every single seed comes from real quantum hardware

I wrote the full technical breakdown over on Dev.to: I Used a Real Quantum Computer to Generate Art, and the Randomness Is Nothing Like What Algorithms Can Do, covering the smart contract, the IPFS pipeline, and the complete Python.

Would I do it again? Yes, but I'd start on IBM and treat Origin as the second source from day one, instead of discovering that lesson mid-collection. If you try this yourself, expect the first seed generation to feel like magic, the second to feel routine, and the queue wait times to feel like a personal attack. The collection is on-chain at Quantum Genesis; next up I'm breaking down the whole pipeline layer by layer, from measurement to mint.

Comments

Post a Comment

Popular posts from this blog

Getting Your Collection Visible on OpenSea, Step by Step

Image
Once the contract is deployed and the tokens are minted with metadata on IPFS, the next step is making them discoverable somewhere people actually browse. For us that meant OpenSea, and the process turned out to be less obvious than the one-and-done marketing made it sound. This guide is the step-by-step I ended up following, using our own collection ( Quantum Genesis on Polygon) as the running example. The good news if you're on Polygon, like us: listing a token for sale is gas-free for the seller because it's a signed off-chain order, not a transaction. Before you start Make sure these are in place first: A deployed ERC-721 or ERC-1155 contract — OpenSea auto-detects contracts on Ethereum, Polygon, Arbitrum, Optimism, Base, Avalanche, and other supported chains. Minted NFTs — tokens must exist on-chain; OpenSea reads directly from the blockchain. Metadata on IPFS or a reliable host — each token's tokenURI must resolve to valid JSON with name , description , imag...
Read more

Polygon versus Ethereum for an NFT contract, from the gas bills up

Image
When we set out to put the Quantum Genesis collection on-chain, the first question wasn't about art or metadata. It was: where do we deploy? The answer looks obvious in hindsight, but only because we sat down and counted the actual costs before writing a single transaction. We minted 100 pieces on Polygon for roughly $1 in gas. The same operations on Ethereum mainnet would have run us $500 to $2,000 depending on the day. That gap shaped every decision that followed, so I want to walk through the numbers we saw and the tradeoffs we accepted along the way. Fair warning up front: Polygon is not a strict upgrade over Ethereum. It's a different security model with real compromises. Our reasoning was that for recording ownership of generative art, those compromises were acceptable. Here's the comparison that convinced us, and the cases where I'd make the other choice. The numbers that mattered Ethereum gas is a moving target, so any figure you read is a snapshot. A stand...
Read more

Quantum Error Correction, or Why Your Qubits Forget What They Were Doing

Image
Every time I ran a circuit on IBM's ibm_fez to generate art for the Quantum Genesis collection, the results were never perfectly clean. There was always noise. Errors crept into every measurement, every gate operation, every qubit interaction. Most people read that as a problem. I turned it into the whole point of the project. But before I could appreciate the noise, I had to understand what it actually is. Quantum computers leak information. They forget. They are not like your laptop, where a bit stays a bit until you tell it otherwise. A qubit is a fragile thing, and the whole industry is spending enormous effort just trying to keep one honest. This post is about how that works — the error correction codes, why the naive "copy it three times" trick fails, and where the field actually stands today. Why qubits fail A classical bit stored as a voltage in a transistor stays 0 or 1 reliably as long as the circuit has power. Copy it a billion times and it won't deg...
Read more