NAND / LATCH
NAND performs logic; LATCH stores one bit of state. In TapeOut they are ERC-1155 components that can be held and burned, like building blocks for circuits.
01 / At a glance
Think of TapeOut as an on-chain circuit design league
You assemble a circuit from on-chain NAND and LATCH components, then fabricate the design into a circuit NFT. That circuit can solve one of the official tasks. After it passes verification, it can be registered as a miner and earn BEM according to real input cost and design quality.
1
Get components
Hold NAND / LATCH tokens.
2
Build a circuit
Connect inputs, gates, and outputs.
3
Fabricate
Burn components and mint a circuit NFT.
4
Choose a task
Select a public circuit specification.
5
Verify
The contract samples inputs and checks outputs.
6
Mine
Register the miner and earn BEM.
In one sentence: fabrication manufactures the circuit; mining enters it into a design competition. Finishing fabrication does not automatically start mining.
02 / Four core concepts
Put each term in its proper place
Circuit netlist
A netlist records every gate, its connections, and how outputs are produced. It describes an executable digital circuit, not an image or ordinary text.
Fabricated circuit NFT
Once a netlist is submitted, its NAND and LATCH components are permanently burned and a circuit NFT representing the design is created on-chain. It can be executed, transferred, or entered into task competition.
BEM
BEM is the reward token for Proof of Design mining. It is neither a component nor the circuit itself; it is the protocol's distribution for design input and contribution.
03 / Tapeout
“Tapeout” is not physical wafer fabrication
In semiconductor manufacturing, tape-out means sending a finished design to a foundry. The TapeOut protocol borrows that metaphor: connect logic gates into a netlist, submit it on-chain, burn the components it consumes, and create an executable circuit NFT.
Before tapeoutNAND / LATCH tokens
+ a temporary browser design
+ a temporary browser design
→
After tapeoutComponents are burned
+ an on-chain circuit NFT
+ an on-chain circuit NFT
A useful shorthand is:
On-chain logic components + connections
↓
A permanently fixed executable circuitTapeout only turns a design into a formal circuit. It does not automatically mean the circuit has solved an official task or entered the main mining reward pool.
04 / Official tasks
The task library is a circuit design exam
Each task defines public input-output behavior. The goal is not to copy one circuit, but to implement the same behavior with your own structure.
| Task element | What it defines | Example |
|---|---|---|
| Input specification | How many input bits the circuit receives and whether input arrives every cycle. | Two 4-bit numbers |
| Output specification | How many bits to output and what they mean. | Sum and carry |
| Behavioral rule | Which result is correct for each input. | 1 AND 1 = 1 |
| Official vectors | Input and expected-output pairs used to test circuits. | 00 → 0, 11 → 1 |
Why have a reference implementation?
It acts like a textbook solution: it proves the task is solvable and establishes a cost baseline. Key task and reference parameters are frozen when the task is published, so anyone can audit them.
The official task page currently shows 306 tasks, of which 267 can be listed for mining. Counts and status may change as the protocol evolves.
05 / Proof of Design
Mining rewards design, not hash luck
BEM mining works more like an on-chain circuit design league: you irreversibly burn components and use them to produce a correct, compact design. Rewards account for both contributions.
Material cost: what you burned
The protocol records NAND and LATCH components truly burned at this layer as material cost b*. This recognizes irreversible on-chain input.
Design quality: how well it is built
The protocol calculates design cost from circuit area and critical-path depth. A lower cost is more likely to become the current best original design for that task on that processor.
H = ( b* + Ktask × q ) × PIn plain terms: material cost plus a design premium, multiplied by the processor coefficient. The premium mainly goes to the current best original design.b* = n + λburn · mn is NAND burned at this layer; m is LATCH burned at this layer.A = g + λ · sArea is derived from gate count and state bits.C = A · max(d,1)βCost combines area A with a critical-path depth penalty d.q = clamp(Cref / C)Your design cost is compared with the reference cost within set bounds.The best original design is not simply the first submission. On the same task and processor, a strictly lower design cost can take the leading slot. Commitments and submission order matter only when costs are exactly equal.
Competition
What does “taking the top slot” mean?
After a circuit passes verification, the protocol computes design cost C. If it is strictly lower than the current leader, the circuit takes the top slot and receives the design premium. The previous leader can continue earning its base material reward but loses the premium. Equal costs are resolved by commitment and timing rules.
Verified and unverified pools
| Pool | Requirement | Reward logic |
|---|---|---|
| Verified pool | The circuit passes sampled official tests and registers against the task. | The main pool, distributed by design power H; the website currently assigns it 99% of daily output. |
| Unverified pool | The circuit has real material cost but has not claimed and proven a task. | Receives only the material-cost share; the website currently assigns it 1% of daily output. |
06 / Verification
How does the contract know your circuit is correct?
When a circuit claims a task, the contract samples official test vectors, runs the circuit, and compares every output bit. Current rules require at least three sampled vectors; the count also depends on circuit size and affordable execution gas.
A
Choose a task
Submit the task ID and circuit.
B
Sample vectors
Select cases from the official test set.
C
Run the circuit
Execute it and compare every bit.
D
Register miner
Enter the relevant pool after passing.
Important limit: passing sampled tests is not a mathematical proof for every possible input. Anyone may later submit a counterexample vector. If the circuit fails it, the design premium may be removed or reduced; the base material reward is a separate layer.
Public correction
What is counterexample review?
Anyone can search for an input that exposes an error in a seemingly correct circuit. That input is a counterexample.
Example: a 4-bit adder produces the wrong result for 1010 + 0111. The contract reruns the circuit and checks the official answer. If the counterexample is valid, the design may lose its leading status or premium.
This is an ongoing public error-finding mechanism, not a one-time seal of correctness or a proof over all inputs. Base material rewards and design premiums remain separate.
07 / Originality protection
A commitment is a sealed answer submitted first
Transactions and netlists on a blockchain may be publicly visible. Publishing a complete design first could let someone copy and front-run it. A commitment records a design fingerprint without revealing the design yet.
Commit firstHash(design data + random salt)
Only the hash goes on-chain
Only the hash goes on-chain
→
Reveal laterFabricate and reveal the circuit
The contract checks the fingerprint
The contract checks the fingerprint
Commitment = Hash(address, processor, netlist fingerprint, salt)
Reveal the netlist later:
Hash(the same netlist + the same salt) == on-chain commitment
→ proves the design was prepared earlierThe salt is a random value you generate. Without it, someone might guess common small circuits and reverse-match the hash. With it, the commitment acts like a sealed envelope only you can open.
A commitment protects authorship order; it does not hide the design forever. The actual netlist must eventually be public or readable so the contract can verify the task.
08 / Complete example
Connecting the steps with an AND task
Task: implement AND using NAND
Illustrative flow, not an instruction to transactSpecification: inputs A and B; output A AND B. Official tests include 00 → 0, 01 → 0, 10 → 0, and 11 → 1.
N1 = NAND(A, B)
OUT = NAND(N1, N1)- Prepare: hold enough NAND tokens.
- Design: connect the two logic layers on the canvas.
- Commit (optional but useful for authorship): register a hash of the netlist fingerprint and a random salt.
- Fabricate: burn two NAND tokens and create a circuit NFT.
- Claim the task: choose AND; the contract samples official vectors.
- Start mining: register the miner after passing. A sufficiently low design cost may also take the leading slot.
09 / Limits
Common misunderstandings
“Tapeout starts mining”
No. Tapeout creates a circuit NFT; mining still requires choosing a task, passing verification, and registering the miner.
“Burning more always earns more”
Not necessarily. Material cost rises, but oversized or deep circuits reduce design quality. The protocol rewards real input and structural optimization together.
“You must copy the reference”
No. The reference is a behavior and cost baseline. Any gate structure is valid if its output behavior is correct.
“Passing samples proves everything”
No. Sampling is an automated on-chain test; counterexample challenges can still expose errors later.
“Commitments provide privacy”
They mainly prevent front-running, not provide permanent privacy. A commitment must eventually be revealed and checked.
“BEM is circuit material”
No. NAND and LATCH are components, circuit NFTs are artifacts, and BEM is the PoD mining reward.
10 / Suggested order
Understand first, act later
- Start with the canvas: understand NAND, LATCH, inputs, and outputs.
- Then inspect the task library: specifications, references, material cost, and design cost.
- Read the algorithm page: understand
b*,C,q,H, and sampling. - Study commitments last: understand why a design fingerprint is registered before tapeout.
Four lines to remember:
Tapeout manufactures a circuit; a task defines behavior; mining is a design competition; a commitment protects authorship.
Tapeout manufactures a circuit; a task defines behavior; mining is a design competition; a commitment protects authorship.
Appendix / Circuit containers
Give a circuit an account, memory, and action interface
A circuit container can be understood as a smart-contract account bound to a circuit NFT, similar to an ERC-6551 token-bound account. It is not an ordinary personal wallet: it has no private key, and control follows the current NFT holder.
A circuit-specific address
Each circuit NFT can have an on-chain address that receives BNB, holds ERC-20 or ERC-1155 assets, and binds those assets to the circuit's identity.
Control transfers with the NFT
The circuit NFT holder operates the container under its permission rules. Selling the circuit generally transfers control of its container, assets, and revenue as well.
Manage persistent state
A container can call storage contracts such as RAM to keep game scores, rounds, and claim records on-chain, so a circuit does not simply forget everything after computing.
Act on behalf of the circuit
The circuit evaluates rules; the container transfers assets, writes state, and calls other contracts. It can serve as the circuit's treasury and external contract interface.
Circuit = logic; container = circuit account + state/asset interface; RAM = persistent storage managed by the containerLimit: a container is neither a conventional EOA wallet nor an oracle that proves real-world data. It gives the circuit an on-chain identity and the ability to operate assets and state; circuits and contracts must still define the actual rules.
Case library / Applications
From “can compute” to “can be called by applications”
The cases below are ordered by their first cited X post, in UTC. Some are official demos, some are third-party experiments, and some connect to assets and business flows. Together they show circuits evolving from NFTs and mining credentials into public functions, state machines, application components, and transferable control.
Official 4-bit CPU · 2026-08-15 08:26 UTC
Built from 2,302 NAND gates and 77 LATCH units, 2,379 components in total. It includes a program counter, accumulator, carry logic, and registers, and executes instructions one by one. A Fibonacci program shows how logic plus state becomes a processor.
What it shows: a circuit can do more than one combinational calculation. With LATCH state, it can execute a program over successive clock cycles.
Bitcoin Miner · 2026-08-16 08:54 UTC
A backend continuously runs a complete 354,560-gate SHA256d netlist off-chain to try real block nonces. Separately, an on-chain single-round SHA-256 circuit can be called for 64 rounds to independently reproduce the standard hash.
What it shows: one circuit design can support off-chain high-frequency execution plus public on-chain verification, while the live mining stream itself is not executing every hash on-chain.
BNN / NANDCORE · 2026-08-28 07:02 UTC
A third-party developer demonstrated a 64–32–10 binary neural network, compressing weights and activations into binary logic and using NAND, LATCH, and TapeOut / Behemoth cells.
What it shows: training normally happens off-chain, while the trained result can be compiled into deterministic circuitry whose inference path anyone can recompute.
Official Linux · 2026-09-07 13:37 UTC
The official case describes circuit #4246 managing an on-chain RISC-V machine through its container: 32 registers, CSRs, and 16 MB of copy-on-write memory implemented as 16,384 contracts of 1 KB each. Booting Linux 6.5.12 to root login took 44,988 cycles and over 9,000 transactions.
What it shows: the circuit defines instruction rules, a motherboard contract advances execution, page contracts store memory, and the container defines administration. Together they form a computer whose state persists on L1.
Xinhuo Prize Draw · 2026-09-08 02:27 UTC
The application verifies drand randomness, calls Behemoth circuit #2075 to calculate candidate numbers, then lets a draw contract select the winner and settle funds. One percent of each round's revenue goes to the container of circuit #13061.
What it shows: one public circuit can serve as a computation module, while another circuit's container acts as a project revenue account. Computation and receipt of funds are separate paths.
21-NAND vehicle · 2026-09-08 19:14 UTC
A third-party developer trained a logic-gate network off-chain, distilled it to 13 gates, converted it into 21 NAND gates, and fabricated it as circuit #279 on a custom processor. It accepts 15 sensor bits and outputs a two-bit steering decision.
What it shows: a learned policy can be compressed into a small Boolean circuit, and every steering decision can then be recomputed by BSC nodes from a fixed netlist.
Microduck's dual-circuit brain · 2026-09-09 15:56 UTC
The open-source robot duck uses one circuit to read the road and another to remember steering. In 100 randomized starts, 90 reached the goal with one circuit and 94 with memory added. A contract combines both circuits, while overall control is held by the memory circuit's container.
What it shows: multiple circuits can form one application, while a container binds control of the combined “brain” to an NFT. Transferring that NFT can transfer control of the whole system.
Circuit Gomoku · 2026-09-10 08:03 UTC
A third-party community member published a game page inviting users to play Gomoku (five-in-a-row) against a TapeOut circuit.
What it shows: a circuit's use case can extend beyond pure computation and state storage to acting as an opponent in interactive entertainment, letting anyone directly experience a circuit's "behavior."
Black Myth-style boss brain · 2026-09-10 11:05 UTC
A third-party developer wired seven TapeOut circuits together as the decision-making "brain" for a Black Myth: Wukong-style boss (the "Sleepless Guardian"). In the demo, circuits #3434 and #2004 fire alternately; animation, collision, and damage are still handled by the game engine, while the circuits only choose the next action. No interactive demo link is public yet — details come from the announcement posts and their videos.
What it shows: a circuit can serve as just the "decision layer" of an application, working alongside an engine that handles rendering and physics, rather than owning the whole system.
Four questions clarify any TapeOut case: Where does its input come from? Where does computation actually happen? Who stores the state? Who owns the assets and control? These questions reveal more than simply asking whether something is “on-chain.”
Official record / Milestones
TapeOut official milestones
This timeline includes only protocol milestones, official capabilities, and official data published by the founder 
@Blonskr, plus official partnership announcements from partners. Third-party tools and community applications remain in the case library above.
First on-chain 4-bit processor revealed
The founder published a cycle-verified 4-bit processor built from NAND and LATCH components. Running Fibonacci demonstrated TapeOut's technical starting point.
TapeOut Protocol Alpha launches
The protocol formally defines transistor tokens, tapeout, circuit NFTs, and composable circuit calls, turning the prototype into a permissionless manufacturing protocol.
First official application: Bitcoin Miner
The official SHA-256 circuit demonstrated callable, bit-by-bit reproducible on-chain logic and gave TapeOut its first application beyond a processor.
Transistor marketplace launches
NAND and LATCH become freely tradable through an on-chain order book, adding a secondary market layer to the manufacturing protocol.
PoD formula and official task library published
The official material-cost, design-cost, and “best original” rules were published, followed by a task library with references, task coefficients, and reference costs.
PoD mining opens to everyone
The official miner example goes live. Circuits can claim tasks, pass verification, and enter rewards based on material input and design contribution.
BEM launches on BNB Chain
The official ERC-20 reward token launches with a total supply of 21 million. Mint authority belongs to the PoD mining contract, not a regular wallet.
One-click task-to-circuit fabrication
Every PoD task receives an official template, so users can create a corresponding miner circuit without drawing a netlist by hand.
First official BNN prototype
The official demo puts binary neural-network weights and inference on-chain, using handwritten-digit recognition to extend TapeOut toward verifiable neural inference.
V2 core design announced
The official preview introduces component slots, a device warehouse, third-party component review, and developer revenue sharing. This is a design preview, not a V2 launch announcement.
PoD fairness mechanisms upgraded
Counterexample review was submitted and became effective about 48 hours later, allowing anyone to challenge faulty circuits. “Originality recorded” was added to resist copied netlists front-running an original commitment.
V1 security audit completed
The founder announced completion of Salus's TapeOut V1 audit and reported zero high or critical vulnerabilities.
Circuit container system launches
Circuits gain containers that can hold assets, RAM, contract permissions, and revenue. Logic can now preserve state and take actions instead of only computing.
Official Linux computer goes on-chain
The official demo combines a RISC-V circuit, a container, and 16 MB of paged memory, executing Linux instructions one by one through BNB Chain L1 transactions.
26-day ecosystem data report
The founder reported 34,054 BNB in total volume, 24,360 fabricated circuits, and 14,964 registered miners; third-party markets contributed about 31% of transistor secondary-market volume.
UPay payment card partnership
UPay officially announced a partnership with TapeOut, giving TapeOut users access to payment cards and linking on-chain assets to everyday spending.
Note: the official data report defines its measurement window as 2026-08-14 to 2026-09-09. This timeline uses 2026-08-15, the founder's first public technical prototype post, as the public narrative starting point. All times are UTC.