A chip is a program and a processor together. Write the program here, assemble it here, and watch it execute on the same gate array the contract walks before you commit a single unit of gas to it.
Live on BNB Chain. One transaction deploys a real 8-bit processor, launches its token against it, and mints you the deed to both.
Everything below is one route, in order, and every part of it works today. The first two need nothing from you but a browser: write a program, watch it execute on the real gate array, and design the chip that would carry it without connecting a wallet or spending anything. The last two cost money, and that is the only difference between them. Chip #1 was minted through these four in that order.
The three sections that are not steps sit between them: the instruction set you write against, a worked example of a chip that decides, and what the contracts will not let anyone do.
Whatever is in this box is written into the chip's ROM when it is built, and there is no function anywhere that can change it afterwards. It assembles here against the same gate table the contract walks, so a program that runs here is the program your chip will carry.
Supply is fixed at a billion and there is no mint function anywhere. What you choose is how much of it the curve sells, what the curve opens at, how the trading fee is split, and how many clock edges the reserve is spread across. Every figure below is the factory's arithmetic run on the values you pick.
ChipRenderer is on chain and it is pure: it
takes a chip's address and returns the image, with no server anywhere
in it. The pattern above is your chip's address, cell by cell, so no
two cards are alike and yours cannot be changed by anyone after the
mint, including by us.
Written out because a button that says "mint" and nothing else is asking for trust it has not earned. This is the whole of it, in the order the contract performs it.
Checked against every ticker already taken and written into storage. There is no rename, so this is the one irreversible line in the call.
Your assembled words are stored with the chip. Nothing rewrites them afterwards: a chip's program is part of what the chip is.
A fixed billion, minted once into the chip's own account. No mint function is written into it, so no further supply can ever exist.
The percentage you chose leaves for the pool in the same transaction. The rest stays as the mining reserve, with one door out of it.
step() becomes callable by anybody. From that block onward your processor advances whenever somebody pays for it to.
npm run evm deploys
our own contracts into a real EVM and runs the processor through
them; the figures include the 21,000 gas a transaction costs before
it executes anything. The mint row is measured, like the rest, when there is an
address to measure.
A chip carries its whole state in contract storage, so there is
nothing to look up and nobody to ask: the cycle it is on, where its
program counter sits, what is on its output port and which flags are
set all come back from one call to state().
This table is that call, once per chip. It needs no index, no server and no cache, and it keeps working whatever happens to this page.
Every chip the factory has minted is here, ours and everybody else's, read the same way. The Kind column says which is which. A labelled chip is one this project runs; the rest were launched by whoever launched them.
The label changes what a row says and not what a chip can do.
step() has no owner check on any of them, and there is
no privilege in the contract for a label to grant. It is there so
you can tell the two apart without knowing our addresses by heart.
| Chip | Kind | Owner | Program | Cycle | PC | Out | Flags | Last sponsor |
|---|
step() is in its logs with the cycle it went in on.
That is the whole tape. This page replays it through the same
2,161 gates your browser is already running and compares the
result against what the chip reports on chain. If the two
disagree, one of them is lying and you found it.
config.js and the replay happens in this tab.