- LIQUIDITY
- log2grid ×30
- STRESS
- linearshards ×8
- FLOW BIAS
- linearbars ×8
Drawn by SOLIDITY_SVG_V1 at 0x265eE6a0E321d8581B91a032CE43617Da591dAB4, from this template's own configuration bytes, against a recorded market. The counts above were read out of the SVG the contract returned.
RELICS / Permissionless generative art
Write the generator. The market finishes the work.
A RELICS launch is a generative collection and its Uniswap v4 market, created together in one transaction. The art is not a folder of images — it is a program the chain runs, and the pool's own recorded state is one of the inputs it reads. The four works on this plate are the four templates the studio opens with, drawn by the contract that will draw yours. Change one in the browser, see every seed before you commit to anything, and launch it when it is right.
The sandbox
Build first.
Launch when it’s right.
Nothing in the sandbox touches a chain. You are working on a draft held in your own browser, so you can take as long as you like, throw work away, and come back to it — none of which costs gas, and none of which asks who you are.
- 01
Explore seeds
Walk the generator's own space. Every seed is a different draw of the same rules, and you keep the one you want.
- 02
Simulate market states
Feed the piece the conditions a market can produce and watch what it becomes. The market is an input, not a caption.
- 03
Test the collection
See many outputs at once, the way a collector will. A generator reads differently in a grid than it does alone.
- 04
Model the launch
Supply, quote asset, protection, burn policy — set them, see the consequences, change your mind for free.
Market as medium
The market doesn't just trade the work. It becomes part of the work.
A compatible project resolves its art from two things: the token's own immutable identity, and a set of market readings the creator chose to listen to. The creator writes the mappings — this reading drives that value — and the runtime does the rest, every time the artwork is read.
- drawdown
- 0.526fracture 0.763
- volume
- 0.777density 1.000
- drawdown
- no reading · fracture unset
- volume
- no reading · density unset
Sixteen seeds, ordered by their drawdown reading. Each step is a different token identity with its own reading — not one identity moving through time.
The route
From idea to on-chain.
There is no application, no allowlist and nobody deciding whether your work qualifies. The four steps below are the whole of it, and the first three cost nothing.
- 01
CreateStart from a template, or bring a project you have already built.
Templates are working generators you shape rather than blank pages. A project exported from the creator kit imports as a .relics bundle — inspected and validated before anything is created, and never executed in this page.
- 02
ExploreDraw it again, and again, until the rules are the ones you meant.
Seeds, market states and a full contact sheet of outputs. This is where a generator stops being an idea about a generator: you are looking at the collection, in the shape a collector will see it.
- 03
ProveEverything that will be permanent, shown to you before it is.
Predicted addresses, the exact pinned metadata fetched back and re-hashed, the market you are about to open, and the choices that can never be changed afterwards — each one named as permanent where it is permanent.
- 04
LaunchOne transaction, signed by you, and the project exists.
Token, generative collection, market-aware runtime and the Uniswap v4 pool are created together. There is no second transaction to bind metadata and no pending state to come back to: the collection is complete on receipt.
The object
What actually launches.
- The art is on chain
- A collection's tokenURI computes its JSON and its SVG from chain state when it is read. There is no image file to lose, no gateway to expire and no server of ours in the path.
- The market is an input
- The pool's own history is what the runtime reads. A project's pieces are not decorated with market data after the fact — the conditions are part of how they are drawn.
- Metadata is birth data
- The collection's canonical URI and content hash are written in its own initializer, inside your single transaction. There is no launched-but-pending state to come back and finish.
- Custody, stated narrowly
- Genesis liquidity is held by the immutable locker and cannot be withdrawn through the deployed locker. That is a statement about the locker's bytecode, not about every risk. RC6's surrounding components are upgradeable by a 2-of-3 protocol Safe with no timelock, token prices can fall to nothing, and a creator can behave badly in ways no contract prevents. The locker guarantee is narrow because narrow is what is true.
Where
Every chain on its own terms.
A chain is not a dropdown. Each one has its own gas currency, its own explorer, its own script-byte ceiling and its own set of assets a market can be priced in. Solidity SVG is the art runtime this release launches, on every chain below.
One of your choices
How your market opens.
Creator-elected, and permanent. You pick one of two shapes for your market’s opening before you launch, and it is compiled into your project’s own hook.
- No protection
Buying and selling both pay 1% from the moment the market opens.
One rate, in both directions, from the first second. The market has no opening period that behaves differently from the rest of its life.
- Protected, 98 minutes
The buy-side fee opens at 99% and falls to 1% over 98 minutes; selling pays 1% throughout.
The fee is a real Uniswap v4 dynamic LP fee, so it accrues to the pool exactly as any LP fee does. It is not a transfer tax, and no router, aggregator or direct call is charged differently.
For the first minutes of a market, buying costs a multiple of what the same buy costs later. That removes the advantage of being first in the block, because being first is exactly when the fee is highest.
It does not guarantee equal allocation, it does not identify anyone, and it does not stop a buyer from waiting for the fee to fall and then buying. It prices the first minutes; it does not decide who is allowed to transact in them.
There are no privileged exemptions. The creator, the platform, the deployer and the protocol Safe pay the same buy-side fee as anyone else, because the schedule is a function of time alone and the hook holds no allowlist.
This choice is permanent. The schedule is compiled into your project's own hook at launch, and there is no setter, no admin and no upgrade path that could change it afterwards — not yours, and not the protocol's.
Why here
Three things worth being sure of.
- 01
Your art stays your art.
The generator you write is the generator that runs. It is stored on chain and computed on read, so there is no hosted renderer to change it, no image file to replace and no metadata endpoint of ours in the path. What a collector loads a decade from now is produced by the same bytes you launched.
- 02
See the consequences before you sign.
The choices that cannot be undone — supply, burn policy, quote asset, how the market opens — are shown as permanent where they are permanent, with the outcome rendered rather than described. The sandbox exists so that the first time you see what your launch produces is not after it has happened.
- 03
No application required.
There is no form to submit, no allowlist to join, no reviewer to convince and no queue to wait in. The factory is open on every chain it is deployed to, and it does not know or care who is calling it. That is a property of the contracts, not a policy we could quietly reverse.