TapeOut Protocol
Infrastructure for on-chain hardware manufacturers, on Solana.
The primitive
Every computation can be built from one gate: NAND. It takes two boolean inputs and outputs the negation of their intersection. That is the whole instruction set of the physical world, and it is the whole token model here.
Alongside it sits the LATCH, which holds a single bit and updates on every tick. A world of only NAND gates has no memory, and something without memory cannot be called a computer. One primitive element and one cell of memory are enough to build anything.
Processors
A processor is an identity with its own transistor supply. Creating one stands up two SPL mints, NAND and LATCH, whose mint authority is the processor account itself. The creator sets the total supply and the price per transistor at creation, and both are permanent. Mint revenue is credited to the creator and withdrawable at any time.
The netlist
A design is a flat stream of elements. Signal 0 is a hard ZERO, signal 1 a hard ONE, the next signals are the circuit inputs, and every element appends its output in stream order. Outputs are read from the end of the signal space.
- NAND: opcode 0x00, two 24-bit operands, seven bytes.
- LATCH: opcode 0x01, one 24-bit operand, four bytes.
- REF: opcode 0x02, a 32-byte processor key and a circuit id, so any finished circuit can be dropped into a new design as a black box.
Every operand must already exist when its element is reached, with one deliberate exception: a LATCH may read a signal defined later in the stream. That exception is what makes feedback, and therefore sequential logic, possible.
Evaluation
A tick settles every combinational signal in stream order while each latch presents the bit it is already holding. Only once the stream has settled does a second pass sample each latch's D input into the next state. This is the same procedure in the browser and in the program, so what you watch settle on the canvas is what the chain computes.
Tape out
The word comes from the semiconductor industry: the design goes to the fab and is etched into silicon. Here the netlist is streamed into an account, validated on chain, and the transistors it consumes are genuinely burned. One NAND token per gate, one LATCH token per memory cell. What remains is a permanent circuit that anyone can call and nobody can alter.
Compute
Solana has no free view calls, so reading a circuit means simulating a transaction and taking the return data, which costs nothing. A tick is roughly 140 compute units per element, so a single instruction comfortably evaluates a few thousand gates within the 1.4 million unit ceiling. Designs beyond that need evaluation split across transactions.
Markets
Transistors trade through a bid book: a buyer escrows the full cost in a program-owned account, and a seller fills against it. There are only bids, so nothing can be dumped into a market that has not asked for it. Circuits trade separately at a fixed price, and a listed circuit cannot be transferred out from under a buyer.
The seal
The protocol keeps two separate promises. Sealing the parameters freezes every fee and setting forever, and there is no instruction that undoes it. Freezing the logic itself is the second act: revoking the program's upgrade authority, after which nobody, including the authors, can change how any of this behaves. Until both have happened, treat the protocol as mutable.