Inspired by the BRC-20 experiment. An experiment is not a promise. Nothing here is a promise of value, a market, or a listing.
Version 1 — 28 October 2026.
QBIT-20 is a way to write fungible token records on Qbit. A JSON object goes into an OP_RETURN output. An indexer reads it back, in block order, and keeps the balances. That is the whole protocol. It is small on purpose.
The chain stores text. It does not know ticks, supplies, or balances. A balance in an indexer is not a token on the chain. If you understand that one sentence, you understand QBIT-20.
In March 2023, @domodata created BRC-20 to test one question: can a token standard exist as nothing more than a convention — text on a chain, and an indexer that everyone agrees to read the same way? It worked, and it worked for reasons worth naming.
Simplicity wins. BRC-20 is three operations and a JSON object. Anyone can implement it in an afternoon. Every feature left out was a bug that never had to be fixed.
A fair launch matters more than features. No premine, no team allocation, no private sale. The deployer gets nothing except the right to be first in line like everyone else. People trusted the standard because there was nothing to trust except the rules.
The indexer is the consensus. The chain never enforced BRC-20. The agreement lived off chain, in indexers that all replayed the same rules. That is a weakness and a strength: weak, because no miner settles a dispute; strong, because the rules stay readable, changeable, and cheap.
Bots take everything you leave open. The first BRC-20 tokens were gone in hours to scripts. A fair launch is not a slogan. It is rate limits, written down, enforced by every indexer, before the first mint opens.
The two-step transfer was the part people tripped over most. Inscribe a transfer, then send the inscribed sat. It made sense on Bitcoin, where a token rides on a sat. It was still the most confusing thing in the standard, and the most common way to lose a fee to a mistake.
QBIT-20 keeps what worked and fixes what did not. Everything below follows from those five lessons.
BRC-20 lives inside a Taproot witness envelope. Qbit has no Taproot outputs in its spendable set, so there is nowhere to put that envelope. The inscription has to live somewhere else. On Qbit, the honest place is OP_RETURN — the same place Runes put its records on Bitcoin. One data push, one transaction, no envelope, no reveal.
BRC-20 rides on sats. Qbit has no sat numbering and no sat binding, so there is no inscribed sat to send. That is why the transfer is one step here instead of two: the record and the movement happen in the same transaction, and the receiver is named by the transaction itself. Section 03 explains how.
Qbit's only spendable output is P2MR, and every spend carries a 3,680-byte post-quantum signature. Transactions are large by Bitcoin standards, and fees are paid in bytes. A design that assumes cheap, small transactions would be wrong on this chain. QBIT-20 assumes the opposite: few operations, small records, one transaction per action.
Blocks come about once a minute. That is the clock the whole protocol runs on. Mint windows are counted in blocks, not in minutes, because blocks are the only time the chain agrees on.
A record is a UTF-8 JSON object, written as the single data push of one OP_RETURN output. The field p must be exactly "qbit-20", case-sensitive. "QBIT-20", "qrc-20" and "brc-20" are different protocols and are ignored. A tick is exactly 4 characters, A–Z or 0–9. Amounts are strings of decimal integers. Unknown fields are ignored. Malformed JSON is ignored. An invalid record never fails the transaction; the indexer simply skips it.
Deploy. The first valid deploy for a tick, in block order, is canonical. Later deploys of the same tick are ignored. A deploy mints nothing. It only opens the tick.
{"p": "qbit-20", "op": "deploy", "tick": "QORD", "max": "210000000", "lim": "2100", "dec": "8"}
Mint. Valid only after the tick is deployed, and only after the mint window opens. The minted amount is credited to the sender address — the first input address of the mint transaction, as read by the indexer. Minting stops when the cumulative minted amount reaches max. Overshoot is ignored.
{"p": "qbit-20", "op": "mint", "tick": "QORD", "amt": "2100"}
Transfer — one step. There is no inscribe-then-send flow and no transferable state. Balances have a single column: available. The receiver is the first non-OP_RETURN output of the same transaction. If there is no such output, the transfer is ignored. The sender must hold at least amt when the indexer processes the block. On a valid transfer the indexer moves amt from the sender's available to the receiver's available.
{"p": "qbit-20", "op": "transfer", "tick": "QORD", "amt": "2100"}
The receiver output carries 10,000 bits — enough to sit above the chain's dust limit, so the transaction is accepted. It exists so the receiver is a real P2MR output the chain can identify, not a zero-value placeholder. Those bits belong to the receiver. They are not a fee and they are not burned. The only cost of a transfer is the network fee.
These rules are indexer rules, not consensus rules. A transaction that breaks them is still valid on chain; its record is ignored. They exist so one script cannot take the whole supply in minutes, and so a small mint is still finishable.
Why these numbers: at 20 valid mints per block and ~60-second blocks, 100,000 mints take at least 5,000 blocks — about 3.5 days — even under full demand. The per-address caps bound any single actor to at most 210,000 tokens, 0.1% of supply, without many addresses. The delayed open exists because the deployer knows first; an hour is the smallest honest head start to give everyone else. The fixed amount removes the advantage of splitting one mint into many dust mints, or stuffing a large amount into a single mint.
Order is block height, then transaction order inside the block. Mempool order does not count. Only confirmed blocks are final for deploy, mint and transfer. On a reorg, the indexer rolls back to the common ancestor and replays.
The indexer must read full transactions, including OP_RETURN outputs. Address-only APIs are not enough. If two indexers disagree, there is no on-chain arbiter. Publish the indexer version and the rule set alongside any balance, so anyone can replay the chain and check the answer. A record that is valid JSON but breaks a rule is ignored, not rejected — the transaction stays on chain.
This is the same bargain BRC-20 made. It is worth stating plainly because it is the whole trust model: you are not trusting a contract. You are trusting that everyone reads the same rules the same way.
There is no premine and no team allocation. The deployer receives nothing. There is no roadmap, no foundation, no treasury, and no future development promised. There is no value, no market, and no listing promised. A QBIT-20 record is text on a chain. Holding a balance in an indexer is not holding a token on chain. Broadcast is irreversible.
If this experiment goes nowhere, the records stay where they were written, and that is the whole story. If it goes somewhere, it will be because people kept writing, reading, and agreeing — not because anyone promised them a reason to.
The indexer can be wrong. It is software, written by people, reading a chain. A bug in replay, a missed reorg, or a rule applied differently by two indexers will produce two different balances, and the chain will not tell you which one is right.
The chain is young. Qbit is a new network. Its wallet, its explorer, and its tooling are new too. New software has new failure modes. Start small, verify every transaction on the explorer, and never inscribe more than you can afford to lose to a mistake.
Every transaction is large. A 3,680-byte signature makes even a simple mint several thousand bytes. Fees are small now because the chain is quiet. If the chain gets busy, fees rise with the bytes, and there is no witness discount to save you.
There is no market. Nothing here creates a buyer. A balance with no buyer is a number in a database. Do not inscribe because you expect someone else to want what you wrote.
The first token is QORD. Its numbers are deliberately unremarkable: the supply mirrors Qbit's own 210,000,000, and the per-mint limit keeps a single mint small enough that no one finishes the supply alone, and large enough that the supply can actually be minted.
EXPERIMENTAL. NO AUDIT. IRREVERSIBLE.
Sections 03 and 04 state the protocol. These five rules decide whether two indexers agree. They are the exact rules the reference indexer applies — a record that breaks one is ignored, and the transaction stays on chain.
The full specification — every rule, in one document — is published alongside this whitepaper: Specification — QBIT-20. The canonical Markdown source is QBIT20_SPEC.md.
EXPERIMENTAL. NO AUDIT. IRREVERSIBLE.