NEURAL, Neural Machine Protocol

Manufacturing line

Launch foundry

Open a transistor token on a Pons bonding curve. One billion units, a 1% curve fee, graduation at 4.2 ETH. Supply and pricing seal at launch.

Open the console 02 / Transistors

Mint transistors

Acquire NAND and LATCH manufacturing material from any live foundry. The curve is the factory price; the burned share is public.

Choose a foundry 03 / NAND · LATCH

Compile the neural net

Train a binary neural network on a truth table, seeded, and compile it to a canonical NAND and LATCH netlist. XNOR and popcount replace multiplication.

Open the fab 04 / Machine ID

Tape out machine

Burn the transistors the netlist needs and seal its hash in the same transaction. The machine gets a permanent address derived from token, netlist and author.

Open the machines

Recent tapeouts

All machines

Every machine taped out on the chain, read back from the burn transactions themselves. Name, transistor token, gate counts, the bill that was burned, the author and the netlist hash. Nothing here comes from a form.

Machine	Transistor	Gates	Burned	Author	Netlist
reading the chain…

Live on Pons v2

All foundries

Every launch in Pons' own index, read through and nothing else. Any of them can serve as transistors; $NEURAL is the protocol's foundry once it is launched from the console.

Foundry	Quote	Curve	Market	Deployer	Launched
reading the Pons index…

Protocol core

NAND

Universal combinational logic. Every function in a machine is a tree of two-input NANDs, and every NAND costs one transistor. The compiler shares inverters and picks the smaller cover of each neuron's truth table.

LATCH

One tick of persistent state. Each output of a machine holds its last value in a LATCH, four transistors each. State is the only thing that costs more than logic.

Neural

Binary weights and activations. A neuron is popcount(xnor(x, w)) against a threshold, which is a threshold function, which is a truth table, which is NAND. The whole net is exact logic with no float anywhere.

MINT → BUILD → TAPE OUT → RUN transistor tokens on Pons · netlist in the fab · burn + seal in one tx · MachineRun receipt

Foundry economics

Read the paper

Pons 30 Foundry 70

Every trade on a foundry's curve pays a 1% fee. Pons keeps 30% at the protocol level. The remaining 70% accrues to the foundry's creator fee recipient in the Pons fee escrow, claimable by that address. Tapeouts burn transistors permanently: burned material never restores issuance.

Curve fee: 1% of every buy and sell, fixed by Pons
Creator tax: 0 to 10%, set by the foundry at launch, on top of the curve fee
Launch fee: 0.0005 ETH, paid to Pons
Material cost: 1 transistor per NAND, 4 per LATCH, burned at tapeout
Supply: 1 000 000 000 per foundry, sealed at launch, never reissued

Quickstart

Record layout

Browser, any wallet

Connect a wallet on Robinhood Chain. Compile, then tape out. Two clicks, one signature.

fab.html → compile → tape out
bill = NAND + 4 × LATCH

The tapeout transaction

One transfer to the burn address. The record rides behind the two ABI words, where Solidity never looks.

to:    transistor token
data:  transfer(0x…dEaD, bill)
       ++ 4e545031            marker
       ++ keccak(netlist)     32 bytes
       ++ nand, latch         4 + 4
       ++ in, out, name

Machine address

Derived, never chosen. The same netlist by the same author on the same token is the same machine.

machine = keccak(
  token, netlistHash, author
)[12:]

Questions

What is a transistor here

A fungible fabrication material issued by a foundry: an ERC-20 launched on a Pons v2 curve. Each NAND gate in a netlist consumes one unit, each LATCH four. $NEURAL is the protocol's own foundry, but any Pons token can be used as transistors, since a tapeout is only a transfer with a record behind it.

What does the fab actually compute

A binary neural network: weights and activations in {-1, +1}, so every neuron is a popcount of XNORs against a threshold. Training is seeded hill-climbing on the task's full truth table, in your browser. The same task, width and seed always give the same net, the same netlist and the same hash. Verification simulates the netlist against the net on every input vector before anything is burned.

Why is the tapeout a plain transfer

Because it has to work with any token and no permission. Solidity's ABI decoder reads the two words that transfer(address,uint256) declares and ignores everything after them. So the burn and the record share one transaction hash, and the index is rebuilt from Transfer events to the burn address alone. There is no registry contract to trust, or to break.

What does it cost

A foundry costs the Pons launch fee, 0.0005 ETH, plus gas. A tapeout costs the bill of materials in transistors, plus one transaction's gas at this chain's 0.027 gwei. NEURAL takes no fee anywhere.

Which chain

Robinhood Chain (chain id 4663). Pons v2 is the launchpad there; graduated foundries move into a locked Uniswap v4 pool. The Pons factory and fee escrow are verified on Blockscout. Pons v2 itself is not audited as of September 2026.

Contracts

Live index

Pons v2 factory: 0x7eD598BcEf8bd9Edd8C97A195C6d13f40801EC7e

Pons fee escrow: 0xd3AFEB2a57f70eF218Aa82451c51B2fb0416Ac9e

Burn address: 0x000000000000000000000000000000000000dEaD

Machines are computed from public chain data and say nothing about future launches. This is not investment advice.