Posts

The future of quantum art: after 100 NFTs

Image
On March 19, 2026, we finished minting 100 Quantum Genesis NFTs — each one generated from measurements on real quantum computers. NFTs #1 through #18 came from Origin Quantum's WK_C180, a 180-qubit superconducting chip in Hefei, China. NFTs #19 through #100 came from IBM's ibm_fez and ibm_torino processors in the United States. The art is on IPFS, the tokens are on Polygon, and the collection is live on OpenSea . Now we're asking: what's next? This post is part retrospective, part roadmap, part speculation about where quantum art goes from here. Some of these ideas are technically feasible today. Others will require hardware that doesn't exist yet. All of them are worth thinking about. What 100 NFTs taught us Building Quantum Genesis was an education in both quantum computing and digital art infrastructure. Quantum computers are real and accessible. This surprised people outside the quantum industry the most. You can run circuits on a 156-qubit quantum proces...

Bridging Python and Solidity: From Generated Art to On-Chain NFT

Image
When I first started Quantum Genesis, I kept hitting the same wall. The art pipeline — quantum circuits, measurements, SHA-256 seeds, SVG rendering — lives entirely in Python. But the ownership side, the ERC-721 tokens and royalties, has to live on-chain in Solidity. Getting those two worlds to talk to each other turned out to be its own project. This post is the bridge. Everything here is real code from our pipeline: compiling a Solidity contract with solcx , deploying it with web3.py , pointing it at IPFS metadata, and minting tokens — no JavaScript toolchain required. If you've ever wondered how to drive a smart contract from a Python script that already generates your art, this is the walkthrough I wish I'd had. Two worlds, one pipeline Before any code, you have to keep the separation clear: Layer Language Responsibility Off-chain Python Quantum circuits, measurements, art generation, IPFS upload, contract interaction On-chain Solidity Token ownership, supply cap, roya...

Provenance Over Aesthetics: Why the Origin Story Matters in Generative Art

Image
Here's the situation that made me rethink the whole project. In 2024 someone could generate a thousand "unique" artworks in an afternoon with Midjourney. By 2026 those tools are faster still. If anyone can make infinite images, then the question that actually separates one piece from another stops being "is this pretty?" and becomes "why should I believe this is scarce?" The answer, I came to believe, is provenance — not aesthetics, not rarity traits, not a floor price. The verifiable origin story of how a thing came to exist. This post walks through the reasoning and the mechanics. If you're building generative art, whether or not you care about quantum computers, I think the question of provable process is the one that's going to matter for the next few years. The provenance problem Anyone can generate art now. A teenager with a free Stable Diffusion instance can produce photorealistic paintings. A Python script with three libraries can ...

SHA-256 for Developers: Turning Quantum Noise Into Deterministic Seeds

Image
Every piece in Quantum Genesis starts with a quantum measurement — a probabilistic event that produces a distribution of bitstring counts. But art generation needs a single, fixed seed to reliably reproduce an image. The bridge between probabilistic quantum data and deterministic art is SHA-256. What I want to show here isn't just what SHA-256 is. It's the specific way we use it, because the naive version has a subtle bug I hit the first time: the order of the measurement results matters for reproducibility, and if you get that wrong your "deterministic" seed stops being deterministic. This is the corrected pipeline, with complete Python code you can run yourself. What a hash function is A cryptographic hash takes input of any size and produces a fixed-size output. Three properties are what matter: Deterministic — the same input always gives the same output. On any machine, in any language, forever. One-way — given the output, you can't reconstruct the inp...

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...

Quantum Computing for Beginners, Without the Physics Degree

Image
I learned quantum computing the way I learn most things: by getting my hands dirty before the theory stuck. I didn't start with a physics degree — I started with Qiskit and a bunch of broken circuits. This post is the version of that journey I'd hand to a fellow programmer: a mental model you can actually use, followed by code you can run on real hardware today for free. If you can write Python, you can write quantum circuits. The math is genuinely fascinating, but Qiskit and friends abstract enough of it that you can build things immediately and pick up the theory along the way — which is exactly what we did for Quantum Genesis. Bits: what you already know Your laptop runs on bits. Each bit is 0 or 1, and everything your computer does — rendering this page, playing audio, running code — is billions of 0s and 1s shuffled around very fast. A byte is 8 bits and holds 256 values (2^8). A 64-bit processor handles 64 bits at a time. It's deterministic and predictable: set a v...

The ERC-721 Metadata Standard, Readable End to End

Image
The most demoralizing bug I hit early on wasn't in the smart contract — it was a blank card on a marketplace. The token existed, the contract was correct, and yet nothing rendered. The problem was metadata: one malformed JSON field and the whole display chain silently breaks. That's why I care about this standard more than the hype around it. An ERC-721 token is, at its core, just a number owned by an address. Everything people actually see — name, image, description — lives in a separate metadata file that the contract points to. This post is a working reference for getting that metadata right, from required fields to the display types that control how marketplaces render your traits. I'll use our own Quantum Genesis metadata as the concrete example throughout. How ERC-721 metadata works The token is just a number (token ID) owned by an address. By itself it has no image, no name, no description. All of that lives in metadata — a JSON file the contract references thro...