Generative art that lives entirely on chain.
A solo build where the smart contract is the artwork: every piece drawn deterministically from its own token, no server, no IPFS.
01 · The problem
What Luce set out to solve.
Most NFT collections are art in name only. The image sits on a centralized server or an IPFS pin someone has to keep alive, and the token on chain is just a pointer to a file that can rot, move, or vanish. Collectors are told they own something permanent while the thing they own depends on infrastructure they do not control. Luce set out to make the opposite true: the artwork should be the contract, and it should outlive every server it was born on.
02 · Context and insight
The reframe that set the direction.
Generative art had its moment with platforms like Art Blocks, but most of that work still rendered off chain and stored output externally. The honest version of the idea is harder: derive each piece deterministically from on-chain data so the same token always produces the same image, with the rendering logic published and verifiable rather than hidden behind an API. The reframe driving Luce was that an NFT does not need to store a picture, it needs to store the seed and the rules to regenerate one. Get that right and the collection becomes self-contained, reproducible by anyone, forever.
03 · The approach
The decisions that mattered.
Make the token the seed, not a file pointer
Each Luce piece is generated from its own token ID and the block data at mint, hashed into a deterministic seed. That seed feeds a pseudo-random stream that drives every aesthetic decision: palette, composition, density, and the geometry of the light study the collection is named for. Because nothing is stored as an image, the same token always renders the same artwork, and the metadata points back to the chain rather than to a server that could disappear.
Write the rendering rules to be verifiable
The decision that shaped everything was keeping the generative logic transparent and reproducible instead of treating it as a trade secret. The algorithm is compact and deterministic by design, so a collector can take a token ID and reproduce the exact piece on their own machine. That made the contract and the canvas code a single honest system: the chain holds the inputs, the published algorithm holds the rules, and there is no privileged path that only the artist can run.
Design scarcity into the algorithm, not a spreadsheet
Rather than hand-assemble traits and rarity percentages after the fact, Roger encoded scarcity directly into the generator so rare configurations emerge from the math itself. Edge-case palettes and uncommon compositional structures are reachable only through narrow seed ranges, which means rarity is provable from the algorithm rather than asserted in a metadata table. This kept the collection coherent: every piece is unmistakably Luce, and the unusual ones are genuinely unusual because the code made them so.
04 · How it's built
Designed and shipped solo.
Roger built the entire system solo, from the generative algorithm to the contract to the mint. The art engine is JavaScript on HTML Canvas, written so a single seed deterministically drives layered light geometry, color, and composition; the same code path renders a live preview in the browser and the final piece a collector receives. The Solidity contract was written from scratch on Ethereum, handling minting, supply limits, and seed derivation from token and block data, with metadata resolving back to on-chain inputs rather than an external host. The minting frontend ties it together: connect a wallet, preview the deterministic output, and mint, with the same algorithm running client side so what you see before you commit is exactly what the chain will produce.
Luce shipped as a complete, self-contained collection: 512 deterministic pieces, every one reproducible from its token and the published algorithm, with more than 300 minted by collectors. Because nothing depends on a server or a pinned file, the art keeps rendering as long as the chain and the algorithm exist, which was the entire point. It stands as proof that one person can own the full stack of a generative-art project, from the visual language to the Solidity, without handing any layer to a platform.
What I’d carry forward
The hardest and most valuable constraint was determinism: once you commit to regenerating art from a seed, every random call has to be reproducible and ordered, and that discipline forces a cleaner, more honest design than storing finished images ever would. Building the contract, the algorithm, and the frontend solo made the tradeoffs concrete rather than theoretical, especially around where to derive the seed and how much to compute on chain versus in the browser. It sharpened a conviction that carries into Roger's web3 product work: provenance is worth nothing if the artifact it points to can quietly disappear.