Neural tapeout paper

1. Two primitives

Every machine in the protocol reduces to two building blocks. NAND supplies universal combinational logic: any Boolean function is a tree of two-input NANDs. LATCH supplies one tick of persistent state: it holds the value on its input until the next tick. Together they are enough for any finite machine, and small enough to price.

Material cost is fixed by the protocol sheet, not by a market: one transistor per NAND, four per LATCH. State is the only thing that costs more than logic. A transistor is a fungible fabrication material issued by a foundry, an ERC-20 launched on a Pons v2 curve on Robinhood Chain.

2. Neural compile

The fab compiles binary neural networks. Weights and activations live in {-1, +1}, so the dot product of an input vector with a weight vector is a count: popcount of XNOR, minus popcount of XOR. A neuron fires when that count clears its threshold. Multiplication is gone; what remains is exactly the kind of function NAND is good at.

neuron(x) = 1  if  Σ_i w_i · x_i  ≥  θ      with  w_i, x_i ∈ {-1, +1}
          = XNOR + popcount against a threshold
          = a threshold function
          = a truth table over its inputs
          = NAND

Training is seeded hill-climbing on the task's full truth table: flip one weight or shift one threshold, keep the move if it is not worse, restart from a fresh seed when stuck. It runs in the browser in well under a second for the tasks on the sheet. The point is not speed, it is determinism: the same task, width and seed always yield the same net, the same netlist and the same hash, on any machine.

Each neuron is compiled from its own truth table as two-level NAND logic. The compiler picks the smaller cover, ones or zeros, shares inverters between neurons and memoises identical gates, so the count printed on the sheet is the count that is burned. Each output of the machine is held in a LATCH.

3. Canonical netlist

A netlist describes the exact gate topology. To be canonical it must have unique drivers, a valid topological order for every combinational path, and explicit sequential feedback. The fab emits gates in creation order, which is already topological, then renumbers: inputs take ids 0 to n-1, gates take dense ids after them, and every key sits in a fixed order.

{"v":1,"in":2,"out":1,"g":[["N",0,0],["N",1,1],["N",0,3],["N",2,1],["N",4,5],["L",6]],"o":[7]}
N a b   two-input NAND of signals a and b
L d     LATCH holding signal d
o       the outputs, always LATCH ids

netlistHash = keccak256(utf8(canonical JSON))

Before anything is burned, the fab simulates the netlist against the trained net on every input vector. A machine that does not match its model is not taped out.

4. The tapeout transaction

Tapeout burns the exact bill of materials in the same transaction that seals the machine. It is one call to the transistor token, a plain transfer to the burn address, with the tapeout record appended after the two ABI words. Solidity decodes the words it declared and ignores the tail, so any ERC-20 accepts it and no registry contract stands in the way.

to     transistor token
value  0
data   a9059cbb                                   transfer(address,uint256)
       000…dEaD                                   to: burn address, 32 bytes
       bill × 10^decimals                         amount, 32 bytes
       4e545031                                   marker "NTP1", 4 bytes
       netlistHash                                32 bytes
       nand                                       uint32
       latch                                      uint32
       inputs                                     uint16
       outputs                                    uint16
       nameLength ‖ name                          1 byte + up to 32 bytes

bill = nand + 4 × latch

The fab dry-runs the call with the record attached before asking for a signature, so a token that would reject it costs nothing. Burned material never restores issuance: the burn address has no code and no key.

5. Machine ID and machine address

The Machine ID is the transaction hash of the tapeout. It is the permanent onchain identity of the fabricated circuit: it names the author, the material, the amount burned and the netlist, and it cannot be repeated.

The machine address is derived, never chosen: the last twenty bytes of keccak256 over the transistor token, the netlist hash and the author, each left-padded to 32 bytes. The same netlist by the same author on the same token is the same machine, and two authors taping out the same netlist get different addresses.

machine = address( keccak256( pad32(token) ‖ netlistHash ‖ pad32(author) )[12:] )

6. Foundry economics

Each foundry issues exactly one transistor token with a fixed supply of one billion and a factory price set by its Pons v2 curve. Parameters seal at launch. The creator's allocation starts at zero: a foundry earns from trading fees, not from a hidden reserve.

• Curve fee: 1% of every buy and sell, fixed by Pons. 30% stays with the protocol, 70% accrues to the foundry's creator fee recipient in the Pons fee escrow, claimable by that address.
• Creator tax: 0 to 10%, chosen at launch, a trade tax on top of the curve fee. One to three percent is the sane range.
• Launch fee: 0.0005 ETH, paid to Pons at launch.
• Graduation: at 4.2 ETH raised, the curve closes and liquidity moves into a locked Uniswap v4 pool.
• Burn: tapeouts destroy transistors permanently. Scarcity comes from use, not from a schedule.

Signals a foundry publishes, all readable onchain: factory price, circulating supply, burned material, taped-out machines and the real execution count. NEURAL charges nothing anywhere.

7. Run modes

A machine is executed by evaluating its netlist on an input vector and advancing every LATCH one tick. Three scales, one semantics:

• Mode A, direct: small machines run in the browser or in a contract, the trace is the receipt.
• Mode B, segmented optimistic: medium machines run offchain in checkpointed segments that anyone can challenge.
• Mode C, proven: large machines produce a zero-knowledge proof of the output commitment.

A MachineRun receipt names the machine, the input and output commitments, the executor and the block. Mode A ships with the fab; B and C keep the same canonical semantics and are the protocol's roadmap, not its promise.

8. Verify it yourself

Nothing on this site is a database. The foundries list is Pons' own launch index, read through. The machines list is rebuilt from Transfer events to the burn address since block 52 000 000, keeping only transactions whose calldata carries the marker where the record starts. Open any Machine ID on Blockscout, read the input data, and you will find the netlist hash at byte 72.

Robinhood Chain, chain id 4663. Pons v2 is not audited as of September 2026. Machines are computed from public chain data and say nothing about future launches. This is not investment advice.