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 16:36 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. The author has since published a playable demo link.
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.
NANDPU · on-chain circuit pet brain · 2026-09-11 07:59 UTC
Third-party project NANDPU published a concept demo on BNB Chain: it claims a NAND/LATCH circuit runs gate by gate, letting viewers watch signals move, replay its last "thought," and check the computation against the on-chain circuit.
What it shows: a circuit's computation and state history can be recomputed and verified tick by tick; whether the mapping from "circuit state" to "pet expression or action" is itself on-chain and open, rather than defined only in the frontend, still needs separate confirmation.
Circuit #283 · Agents API control loop on-chain · 2026-09-11 10:15 UTC
A third-party developer compiled the control logic of OpenAI's newly launched Agents API (when to call a tool, when to retry, when to spawn a sub-agent, when to release payment) into a 152-NAND + 10-LATCH circuit. The model and tool calls still run off-chain; the circuit only decides "what to do next," and anyone can recompute it tick by tick. The demo page includes an interactive simulator and logs several different models driving the circuit through a test task.
What it shows: a circuit can carry not just a perception/control policy but a governance rule itself — verification shifts from "what the model is thinking" to "what it is allowed to do," letting third parties confirm whether an agent actually followed the process it claims to follow.
ncd2net · compiling neural networks into NAND circuits · 2026-09-17 10:26 UTC
A third-party developer released ncd2net, which takes a neural network structure described in pyncd (Attention, FFN, Transformer, and other graph structures) and deterministically compiles it through Graph → fixed-point IR → Verilog → the Yosys/ABC synthesis toolchain into pure NAND circuitry, rather than training first and distilling afterward. It has produced an Attention Core (1,024 NAND gates, verified error-free across all 2^24 input combinations), an Attention Block (5,999 NAND gates), and a full Transformer layer (7,448 NAND gates), with a working demo online.
What it shows: beyond the "train first, then distill" route seen in case 03, there is a second route to circuit-izing neural networks — compiling directly from network structure with deterministic guarantees. Reaching the scale of a full Transformer layer suggests this compilation path can plausibly scale to larger, exhaustively verifiable network structures.
Droso (“Xiao De”) · a fruit-fly neural network split into 10,419 circuits · 2026-09-20 20:12 UTC
Third-party developer @0xJayChen describes a digital model based on the fruit-fly nervous system: 166,700 neurons and 25.58 million synaptic connections, compiled into 10,419 TapeOut circuits using 614,721 components in total (583,464 NAND gates and 31,257 LATCH units). The developer says the circuits have been deployed to BNB testnet and that the complete state can be restored locally to execute two consecutive, reproducible computation steps.
What it shows: TapeOut circuits can serve as compilation targets for a large modular state network rather than only as isolated small circuits. The developer also proposes a community build in which different participants supply components, fabrication, tooling, runtime resources, and verification before the modules are recombined into a publicly checkable system.
Current boundary: the disclosed result is “testnet deployment plus local restoration and two steps,” not continuous execution on BNB mainnet. Mainnet operation would still require fabricating more than 10,000 circuits and funding gas, deployment, state maintenance, and ongoing computation. The post does not link the model source, the neuron/synapse-to-NAND/LATCH compiler, public code, or an independent reproduction, so it is not yet possible to assess how faithfully the model represents real fruit-fly biology. The developer also explicitly makes no claim that Droso is alive or conscious.
Conway's Game of Life · one 56-NAND rule reused by 64 cells · 2026-09-20 08:53 UTC
Third-party developer @BruceBlue open-sourced life-tapeout, expressing Conway's B3/S23 Life rule with TapeOut NAND, LATCH, and REF primitives. A 56-NAND rule circuit was exhaustively checked across all 1,024 input combinations; an 8×8 board stores cell state in 64 LATCH units, with every cell using REF to call the same rule. This reduces fabrication material from roughly 3,579 components without reuse to 64 LATCH + 56 NAND, or 120 components total.
What it shows: REF separates “fabricate a rule once” from “call that rule in many places,” allowing many identical units to share one circuit. The saving applies to tapeout material, not per-beat computation: the demo still evaluates 3,648 gates each beat, so reuse structure and runtime cost need to be assessed separately.
Current boundary: the repository explicitly states that nothing has been sent on-chain; the browser demo runs the tested netlist bytes through a local interpreter. Its roughly 9.0M-gas figure per beat is extrapolated from eval() measurements on three deployed circuits, not an actual on-chain Life transaction. This is currently an open-source, exhaustively verified design with a calldata dry-run—not a fabricated or continuously running on-chain application.
Open interactive demo → · View source → · View announcement →
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.”
Business cases
Commercial projects built on TapeOut
Unlike the case gallery above, this section only lists projects that are live, have a clear business model (fees, trading, subscriptions, etc.), and genuinely call TapeOut protocol capabilities rather than just borrowing the name, ordered by launch date.
HashPort · on-chain frontend storage · 2026-09-13 11:13 UTC
HashPort writes dapp/DeFi frontend files directly into BNB Chain state and registers each file's SHA-256 hash on-chain, replacing DNS, CDNs, and npm packages as the hosting layer; compatible wallets recheck the hash on load to prevent a tampered frontend from injecting a malicious signing prompt. Edit rights and the domain hosting fee are bound to an NFT built on a TapeOut circuit container (ERC-6551) — transferring that NFT transfers the whole frontend and its fee arrangement, and the site can be listed for sale on a circuit market, where a listed version is locked from further edits.
What it shows: a circuit container can wrap not just a robot's or a circuit's control rights (see case 07), but also "a website's edit rights plus its fee rights," turning a Web2 asset that was previously inseparable into a single tradeable on-chain claim. The founder calls it TapeOut's first commercial project.
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.
Tape-out feature upgraded to Open Beta
The founder announced the tape-out system is upgrading from Alpha Beta to Open Beta, and asked third-party exchanges and mining platforms with tape-out integrations to make two code changes: read the contract's
TAPEOUT_FEE()value as the transaction amount, and mark thetapeoutcontract method aspayable. The upgrade is scheduled for 2026-09-12 08:00 UTC+0 (16:00 UTC+8).Founder gives up admin control of the BEM mining contract
After Salus completed its audit and the system ran stably, the founder submitted a proposal to give up admin control of the BEM mining contract. The BEM mining contract, token contract, and related contracts will become permanently non-upgradable and unpausable, with total supply and the emission curve locked forever. The proposal has been submitted and takes effect 48 hours later.
BEM mining contract sealed
The renunciation proposal submitted 48 hours earlier took effect: the PodMining contract's
isSealedwas set to true and its owner was removed. The founder says this removes the last risk in the mining contract, and BEM now belongs to everyone.Launch platform TapeHub.ai goes live (Alpha Beta)
On TapeOut's one-month anniversary, the founder announced the launch platform TapeHub.ai: anyone can pick BEM, BNB, or USD1 as the pool currency to launch a mining-coin project; once minting is met, 99% of the raised funds are paired with tokens and permanently locked into a PancakeSwap liquidity pool. Total token supply is fixed at 1 billion, with 95% earned only through mining, output halving across 9 stages over 1,908 days; burning tokens for fuel grants up to a 3x hashpower boost. 50% of tape-out fee revenue flows into the treasury to buy back and permanently burn BEM.
Note: exact economic parameters follow the official docs; claims like "early participants saw 200x returns" have not been independently verified.
TapeOut Protocol deploys to X Layer mainnet
The processor factory, circuit containers, site repository, and TapeSend cross-chain encrypted messaging channel went live on X Layer mainnet, and the first X Layer Processor was created and successfully tested. X Layer is the second chain to join the TapeOut DeWEB after BNB Chain; its address area code is 2, with
1.2.0as an example format.X Layer circuit containers arrive on the TapeOut website
The founder announced that X Layer circuit-container support is now live in the website's Containers section. Users can open an on-chain container for a circuit on X Layer; the container can independently receive, send, and hold OKB or tokens, and hold administrative control over contracts. The announcement draws a clear distinction: a wallet belongs to a person, while a container belongs to the circuit itself—and that circuit may be owned by an AI.
TAPs protocol proposal standards are published
The community published the TAPs repository, a public proposal process for TapeOut protocol standards. TAP-01 defines how ideas move through Draft, Review, Candidate, and Final stages; TAP-10 defines the DeWEB standard across the
tape://access layer and TapeSend messaging layer, including interoperability, test vectors, deployment addresses, and security requirements. This gives TapeOut an open standard that independent browsers, wallets, and apps can implement against.New TapeOut website and desktop clients announced
The founder announced that a redesigned TapeOut website is about to launch, together with desktop clients for macOS and Windows. The announcement expands TapeOut's access layer beyond a web page and points toward a more approachable entry point for the protocol and its DeWEB applications.
Redesigned TapeOut website goes live with cross-chain BEM
The rebuilt official website went live. Its major new capability lets $BEM move between BNB Chain and X Layer through 1:1 lock-and-mint, powered by LayerZero with a typical 1–2 minute delivery time. The founder also stated that both chain contracts have verified source code, making this the first official website release that combines a new access layer with a live cross-chain asset rail.
ITO concept and the next 60-day roadmap published
The founder introduced ITO, or “Initial Tape-Out”: a new project-launch format centered on circuit containers. Unlike an ICO's whitepaper, an IEO's exchange endorsement, or an IDO's liquidity pool, an ITO is described as delivering a genuinely verifiable on-chain production tool or on-chain computing project. The two-month roadmap also prioritizes DeWEB developer tools, deeper BEM partnerships, miner cross-chain access, TapeOut V2 component slots with revenue sharing, and efforts to bring TapeKit into major wallets and regional smartphone platforms.
Founder backs independent community foundations and pledges 700 BEM
The founder endorsed the creation of two or three independent TapeOut community foundations, said the core team would remain outside foundation management, and promised continued technical support. He also pledged a personal donation of 700 BEM once BruceBlue's community foundation formally launches and begins accepting donations.
Mining rigs become cross-chain assets on X Layer
Mining rigs can now keep working and mining BEM on their original chain while also appearing on X Layer for sale, split rentals, collateralization, and one-click BEM claims. Each cross-chain rig is locked in an independent custody contract with editable ownership rights on X Layer, opening paths toward fractionalization, AMM markets, DeFi lending, and RWA-style applications.
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.