The BTX Handbook

Most chains arrive with a founder, a conference talk and a countdown. BTX arrived with a commit.

There is no team page. The GitHub organisation that holds the code says, in plain text, that it has no public members. The project's own site names no founders, no developers and no investors. There was no token sale, no premine and no allocation to anybody. If you want to know who is behind BTX, the honest answer is that mostly you cannot find out, and that the people involved appear to prefer it that way.

What you can find is the work. The reference implementation is at github.com/btxchain/btx, it is MIT licensed, and its commits are publicly authored by a GitHub account called numair, whose display name reads Numair Faraz. That is a checkable fact rather than an announcement: nobody has declared him the core developer, and this handbook is not declaring it either. But if you want to see who is merging the code that decides what a valid BTX block is, the commit list is right there and it takes ten seconds.

It is a more interesting trail than most. Nineteen years ago, in May 2007, a single developer built one of the first music applications on Facebook. VentureBeat covered it at the time and named him. Adweek covered its removal later the same year, reported that it had passed 750,000 users, and explained that entire tracks were being uploaded in clear breach of copyright, which is the sort of problem you only get from having built something people actually wanted. Before that, in his twenties, he advised Motorola's chief marketing officer, the executive widely credited as the father of the RAZR. None of this is secret. It is in the press archives, under his own name.

Around him are people you cannot see at all. Community members refer to a lead architect known as Chuck. He is pseudonymous, easyBTX has no way to confirm anything about him, and this handbook is not going to speculate. That is not evasion, it is the correct treatment of someone who has chosen not to be named.

This is worth sitting with for a moment, because it cuts both ways. A project with no public team has nobody to hold to a promise, and you should weigh that honestly. It also has nobody to enrich, no marketing budget bending the story, and no roadmap written to support a valuation. Bitcoin started the same way, and the fact that Satoshi never came back is now widely regarded as its greatest structural advantage.

The genesis block carries a message, the way Bitcoin's did. Anyone can pull it out of the chain and read it:

BTX 19/Mar/2026 SMILE v2 Post-Quantum Shielded Transactions

That line is a small time capsule, and section 8 explains why it is also a little poignant.

The last thing worth saying in a foreword is the plainest. This chain is young, small and unfinished. Roughly nine easyBTX miners were online on Byron Bay, the pool the app joins by default, the day this was written. There is no exchange, no order book, and no price. Whatever brought you here, you are early enough that the network is still small enough to matter, and early enough that it might come to nothing. Both of those are true at once, and any document that tells you only one of them is selling you something.

easyBTX makes software for BTX: a miner, a node app, and some free tools. It is not the BTX core team. The chain's consensus software is written and released by the BTX project, which easyBTX has no part in and no authority over. We read their source and their releases like anyone else can.

That matters for how you should read this handbook. Nothing here is an announcement, a roadmap, or a promise on the chain's behalf, because those are not ours to make. It is one independent participant's reading of public sources, written so that you can check it. Where the record is unclear we say so, and where we have been wrong before we say that too.

Two disclosures, because the alternative is letting you assume something friendlier than the truth. First, easyBTX has an interest in BTX doing well, and takes a fee from mining, which section 12 states in full. Second, the projects listed at the back are not all arms-length from us. BTX itself is genuinely separate, and that is the separation that matters most. But btx.best and btxscan.io are built by easyBTX and say so in their own footers, and PQ Wallet, the bonuz wallet and qID share people with easyBTX. Where this handbook describes those products, read it as a participant describing the thing he helped build. The chain, the pools and postquantum.wiki are not ours.

BTX is a fork of Bitcoin built to survive quantum computers.

Bitcoin signs every transaction with ECDSA, a classical elliptic-curve scheme. A large enough quantum computer would be able to break it and spend coins that are not its own. BTX replaces that signature scheme with post-quantum signatures, standardised by NIST: ML-DSA-44 for everyday signing, with SLH-DSA as a hash-based backup for the recovery root. That is why a BTX address looks different from a Bitcoin one. BTX addresses begin with btx1z.

Everything else is deliberately Bitcoin-shaped:

• A fixed supply of 21,000,000 coins, with no way to issue more.
• No premine. Coins come into existence only as a mining reward, block by block.
• Proof-of-work mining, with no permission to ask for and no gatekeeper to pass.
• Self-custody. There are no accounts and no custodian. You hold the keys, and the keys hold the coins.

Under the hood it is a fork of Bitcoin Knots, a long-running Bitcoin implementation, rather than a chain written from nothing. That is a point in its favour: the parts that handle money have two decades of adversarial history behind them, and the new work is concentrated where it had to be.

The post-quantum signatures are not free, and the price is visible on chain. Each input of a spend carries about 3.7 kilobytes of witness data, of which the signature itself is 2,420 bytes. The equivalent in Bitcoin is closer to 100 bytes. That is the honest cost of the whole idea, and you can measure it yourself on any transaction in the explorer.

The chain is young. Block 0 is stamped 19 March 2026, and the first block was actually mined on 23 March 2026.

Bitcoin miners search for hashes. BTX miners multiply matrices, the same dense arithmetic that modern AI accelerators are built to do. That is what "matmul" means wherever you meet it in BTX documentation: matrix multiplication, used as the work that secures the chain.

The practical effect is that a GPU is the natural machine for BTX, and that the work is a real numerical computation rather than a hash lottery.

It is worth being precise about what that does and does not mean, because this is the claim most often overstated. The inputs to each computation are seeded from the chain itself, and only a digest of the result is kept. So the computed product is delivered to nobody outside the chain. BTX does not sell AI compute today. A verifiable-compute market, where an outside party submits a real job and pays for the result, is named in BTX's own specification as a later direction, and it does not exist.

What is true today is quieter and more durable: mining BTX pays a distributed crowd of ordinary people to own AI-capable hardware and keep it powered and online, in many independent hands rather than a few data centres.

BTX has had exactly two mining algorithms in its life. It is worth saying that plainly, because the version numbers in BTX's design documents are easy to misread: they describe a research roadmap, not a series of live chains.

MatMul v3 ran from the very first block. One attempt was a single 512 by 512 matrix multiplication over a prime field chosen so the arithmetic maps cleanly onto both CUDA and Apple's Metal. Attempts took microseconds, so a card made millions per second, and mining rates were quoted that way.

That design had a weakness that is easy to state. When an attempt is that cheap, the work drifts back towards being a lottery: the cost of a guess approaches the cost of a hash, and the expensive, AI-shaped part of the machine matters less than the ability to make guesses quickly. The matrices were also small enough to sit comfortably in cache on hardware built for far larger problems.

MatMul v4.7 activated at block 185,000 on 10 August 2026, and it is a different kind of work. One attempt, now called an episode, runs four rounds of a sixteen-layer network 4,096 values wide. It is roughly 141 trillion multiply-accumulate operations, it needs about 4.8 GB of GPU memory, and it takes tens of seconds. The cost per attempt went from a nonce a card could try hundreds of millions of times a second to one indivisible episode. BTX's own fork calibration measured that ratio at 6.93 billion on its NVIDIA launch cohort and 1.15 billion on an M4.

That is the whole point. An episode is indivisible: you cannot half-do one, and you cannot make a cheap guess. To attempt a block you must genuinely commit a large, modern accelerator to a large, modern computation for seconds at a time rather than microseconds. The work stopped resembling a lottery and started resembling the thing the chain claims to be about.

The cost was real and the project has not hidden it. Mac mining stopped working entirely for nine days. Nodes that had not upgraded stopped at block 184,999. Difficulty had to recalibrate. Shares became rare enough that miners reasonably thought something was broken. And cards that had been mining happily the week before could no longer mine at all, because the engine that drives them withdrew its builds for hardware older than the NVIDIA Ampere generation.

A proof of work is only useful if everyone else can check it cheaply. Hashing has that property for free: you redo one hash. Matrix multiplication does not.

Under MatMul v3, BTX used a probabilistic check called a Freivalds test. Rather than redoing the whole multiplication, a verifier multiplies both sides by random vectors and compares, twice. A wrong answer survives that with a probability of about one in 2 to the power 62, which is a number you can treat as never. Checking a block cost a few hundred bytes and a rounding error of arithmetic. From block 61,000 the product digest was bound into the block so this could not be gamed.

MatMul v4.7 changed the deal, and BTX's own release notes are direct about it:

Production Profile 1 ExactReplay remains a qualified-accelerator path. CPU ExactReplay is still an explicit pre-activation or diagnostic path, not an automatic production fallback.

In plain terms: verification today is a full replay. To check a block properly you re-run the episode, which means you need hardware that can run episodes. This is the least comfortable fact in this handbook, so here it is without a cushion. Many nodes on the network today are not independently validating the work. They follow signed verdicts from nodes that can. BTX's own documentation calls the current topology temporary and links a transition plan.

Succinct proofs, where a verifier checks a short certificate instead of redoing the work, are described in BTX's design documents. They have no activation height. They are a design goal, not deployed behaviour, and anyone who tells you BTX has cheap verification today is describing the old work function or the future one.

Setting marketing aside, a few things about this design are notable to anyone who reads consensus code for a living.

• The work is real dense integer linear algebra, deterministic and byte-exact across two independent GPU backends. Two different vendors' hardware must produce the identical digest.
• The change in cost per attempt is a category change, from microseconds to tens of seconds. Very few chains attempt that, and it makes an attempt genuinely indivisible.
• Mining eligibility is a measurement, not a list. The software hands the GPU a computation whose correct answer it already knows, and admits the device only if every byte comes back identical. Both easyBTX and the engine vendor published hardware requirements that turned out to be wrong, and both were corrected by measurement.
• The header never changed. A total replacement of the proof-of-work shipped without adding a single byte to the 182-byte block header, which is why pools, miners and wire protocols survived it intact. That is unglamorous and genuinely hard.

None of this means the work is useful to anyone outside the chain yet. It is not, and section 4 says so. But the machinery is real, the numbers above are in the consensus source rather than a brochure, and the project documents its own rejected parameter choices and disables its own unfinished components in code. That is a better sign than any claim.

Every row below is checkable: the rule and the height come from the consensus source, and the date comes from the block itself in the explorer.

Two entries in that table deserve more than a row.

The chain describes its own genesis as a restart. The comment beside the genesis timestamp in BTX's consensus source ends with the words "SMILE v2 chain restart", and the README refers to a reset chain. easyBTX could not establish what, if anything, ran publicly before 19 March 2026, and BTX's own documentation does not say. We are noting it because it is in the source, and a reader who finds it later should not feel it was hidden here.

BTX is a transparent chain today, whatever you may have read. The genesis message promises shielded transactions, and the project's public launch announcement in July 2026 listed privacy as a headline feature. But consensus stopped accepting new shielded deposits at block 125,000, mined on 8 June 2026, roughly four weeks before that announcement was posted. BTX's own documentation is candid about it: what remains is the ability to view existing shielded balances and move that value back out to transparent addresses. If privacy is why you are here, read the current docs before you go further.

Every block pays 20 BTX. The target interval is 90 seconds. The reward halves every 525,000 blocks. Multiply it out and 525,000 blocks at 20 BTX, then 525,000 at 10, then 5, converges on 21,000,000, which is the hard cap the code enforces. The chain's own test records that integer rounding leaves the final total a fraction of a coin below it, at 20,999,999.93 BTX. You can check both on a calculator, which is the nicest thing about a fixed supply.

No halving has happened yet. The first one is still ahead, roughly a year and a half into the chain's life at the target interval.

At the time of writing the chain had passed block 198,770, so roughly 3,980,000 BTX had been issued, a little under 19 percent of the cap. For current numbers rather than these, see the live stats page listed at the back of this handbook.

No, and the reasons are structural rather than promises.

The supply is fixed at 21,000,000, there was no premine, and coins are created only by mining. BTX is a Bitcoin-derived chain with no token layer, so there is no mechanism to issue a counterfeit coin without breaking the rules that every node enforces independently. Every coin traces back, block by block, to a mining reward.

That is a different question from whether the chain can be attacked. A sufficiently large share of the network's mining power could reorder recent blocks, which is true of every proof-of-work chain including Bitcoin. BTX caps how deep a reorganisation it will accept, and its own vulnerability assessment states the limit plainly: no node-local rule can make a one-confirmation settlement final against a stronger private miner. The research archive carries a full study, along with the steps to verify authenticity yourself.

There is one more way to end up with the wrong thing, and it has nothing to do with cryptography. An unrelated project has used the ticker BTX since 2017. It is listed, it has a traded price, and it is not this chain. If you search for a BTX price you will probably find it. The chain this handbook describes is the one whose reference implementation is at github.com/btxchain/btx.

Mine it. easyBTX is one app for Mac, Windows and Linux. It joins a mining pool, pays out to a wallet you control, and keeps itself up to date. Section 12 covers what hardware actually works and what it costs.

Verify it. Running a full node is the only way to answer questions about the chain without trusting somebody else's server. easyNode makes that one click on all three platforms. Node Guardian diagnoses a node that has stopped moving, and Keeper turns a spare machine into one that serves signed block confirmations, which is the scarcest resource on the network.

Build on it. This is the least crowded of the three and section 14 is about it.

This section exists because getting it wrong wastes your afternoon and your electricity.

On a Mac, the answer is a measurement, not a model number. When easyBTX starts, it hands the GPU a computation whose correct answer it already knows and admits the machine only if every byte comes back identical. That check takes under a second. There is no chip allowlist, and there used to be: an earlier rule that required an M5 turned out to be wrong and was removed. On the day this was written, Macs connected to Byron Bay, the pool the app joins by default, and reporting a passed check included an M1 Pro, an M2, an M3, an M4 and an M4 Max. In practice a Mac also needs macOS 26.4 or later, because earlier versions do not have the tensor operations the work runs on. Intel Macs cannot mine at all.

One caution on that list, because it is the difference between a handbook and a brochure: passing the check and earning are different claims. Those machines had passed the check. Attributing actual earnings to a particular chip is not possible from the public pool data.

On Windows and Linux, you need an NVIDIA card of the Ampere generation or newer, which means roughly an RTX 30-series or later. This is not a preference, it is a hard floor: when the work function changed, the engine easyBTX uses withdrew its builds for older cards, so a Pascal, Volta or Turing card has no engine to run. easyBTX detects this and stops with an explanation rather than pretending to mine. AMD and Intel GPUs are not supported. Windows runs the Linux build under WSL2, which is what people mean by the WSL version.

How long a share takes. Since the fork one episode is the whole unit of work, and it takes tens of seconds. On a measured run, one Apple M5 averaged about 41 seconds per episode and, once the pool had settled its difficulty, saw roughly one accepted share every two and a half hours. One mid-range NVIDIA card measured about 5 seconds per episode, which is roughly eight times faster. A first share can take an hour or more. A quiet hour is usually luck, not a fault.

What it costs. easyBTX takes 4.99% of mining time, and says so in the app, on the site and in its source. The pool takes its own fee on top, which it sets and changes: on the day this was written the two working pools charged 2.5% and 1.5%. On Windows and Linux the MATADOR engine takes a further 1%. So the honest total is roughly 6.5% to 8.5% depending on your platform and pool, plus the electricity, and a busy card pulls well over 100 watts. Check the pool's own dashboard for its current fee rather than trusting this page, because a printed number ages badly.

And the fact that governs all of it. BTX has no public market. What you mine may never be worth anything. Treat it as participation, not income.

A BTX wallet is a key you control, so choosing one is choosing where that key lives.

PQ Wallet is the desktop wallet, for macOS, Windows and Linux. It signs with post-quantum schemes and keeps the key on your machine. How well protected that key is depends on a choice you make when you set it up: a passphrase or Touch ID encrypts it, and choosing neither is faster and leaves the key readable by anyone who can use that computer.

bonuz is the mobile wallet, for iPhone and Android, and carries your on-chain identity alongside the coins. It is worth understanding how it protects your keys, because it is genuinely different: you sign in with Google, Apple or email, and your post-quantum BTX keys are derived from that login rather than from a seed phrase you write down. That removes the single most common way people lose everything, and it means the security of your coins rests on the security of that account. Neither approach is wrong. They fail differently, and you should pick the one whose failure you can live with.

Both are self-custodial, and neither asks you to register. The miner also has a wallet built in, which is enough to receive what you mine, and you can point payouts at either of the wallets above instead.

qID is the piece that connects a wallet to a website. BTX sites use it to sign you in: instead of an email and a password, you prove control of your key. It is worth being exact about what the site learns. It does not learn your name, your email or your key. It does learn your BTX address, and a BTX address is a public ledger entry, so a site you sign into can look up what that address holds and has done. That is a real tradeoff and it is not the same as anonymity.

One thing qID gets right deserves saying plainly: a sign-in proof can never move your coins. Logins and transactions are signed over different, separately tagged digests, so a signature made for one cannot be replayed as the other.

BTX has proof-of-work, post-quantum keys and a small, growing set of users. What it does not have on the base chain is smart contracts. That shapes what you can build today: wallets, explorers, tools, payment flows, anything that reads the chain or signs with a BTX key. It rules out anything that needs on-chain programmability, at least until the second layer in section 15 exists.

The most useful entry point is build.qid.dev, because the first thing most applications need is a way for a user to sign in.

qID Connect is that. If you have used a wallet-connect flow on another chain, it is the same shape: a user clicks a button, approves in their wallet, and your app gets a session. Two things make it worth a look.

The first is that it genuinely cannot be completed with a classical key. The verifier accepts only an ML-DSA-44 signature and rebuilds the address from the post-quantum public key, and BTX has no classical address type to build one from. That is an unusual property and it holds up to inspection.

The second is that there is no relay server in the middle. Your own backend issues the challenge and receives the proof. Nothing about the login goes through qID's infrastructure or anybody else's.

Now the honest boundary, because this is the claim most likely to be repeated wrongly. A post-quantum login does not make your application post-quantum. It makes exactly one thing post-quantum: the proof that a user controls that address. The certificate that names your site, the connection carrying the request and the session cookie your user holds afterwards are all ordinary web infrastructure, and a browser today has no post-quantum certificate authority to use. That is not a flaw in qID. It is where the boundary genuinely sits, and describing it accurately is more persuasive than overstating it.

Getting started is three steps and they are all small: drop in a script tag that mounts the button, mount one middleware on your server, and test against a shipped example that signs with a throwaway key so you need no wallet at all. There is a live demo at qid.dev/connect that runs entirely in your browser.

Before you build on it, know what you are building on. The SDK is young: version 1.0 shipped in July 2026. The identity core has not had an independent audit, and the project says so on its own site rather than waiting to be asked. Its source repositories are not public, although the release pack is MIT licensed and downloadable. And roughly a month into its life the team found a real hole in the QR sign-in flow, one where a bystander who could see the screen could have signed the victim into the attacker's account, published it in their own changelog, fixed it by changing the client contract, and corrected a public claim they had previously got wrong.

That last paragraph is not a warning against using it. It is the most useful thing anyone can tell you about a young project: not whether it has bugs, but what happens when it finds one.

A final disclosure. Every live qID integration you can visit today belongs to the same estate as this handbook's publisher. easyBTX has built a qID integration into its own site and has not switched it on. There is not yet an independent third party in production that you can go and try.

A recurring question is where the fast things go: payments that settle in a second, smart contracts, the trading and clearing layer. The answer the project points to is EVX, and this section is written carefully, because EVX is the part of the BTX story where the gap between the design and the running code is widest.

What it is designed to be. A separate settlement and clearing network with its own BFT consensus, running an EVM so that ordinary smart contracts work, targeting one to two second finality, reading BTX and paying BTX miners from its fees. Its materials describe it as a layer 2 clearing layer for BTX.

What it is not. It is not a rollup, and it does not inherit BTX's security. BTX's own design note is explicit that the dependency runs one way only: EVX reads BTX, and BTX must never require anything from EVX to decide finality. A mechanism that would have coupled BTX's finality to EVX was prototyped and deliberately removed. If you know what a layer 2 usually means, adjust: this is a separate chain that anchors to BTX, not a chain that borrows its security.

What exists today, publicly. A wrapped-BTX bridge and a checkpoint light client, on a test network, in one MIT-licensed repository. The amount of wrapped BTX in existence is 4,002 satoshis. One checkpoint has ever been submitted. The BTX side of that bridge runs on a local test chain, not mainnet, so no mainnet BTX is locked in anything. Its reserve check has been reporting unhealthy since July 2026 because its data feed went stale, which is the gate working as designed rather than a failure. The contracts' own comments describe the current proof mode as an explicitly documented committee mode and not the final trust-minimised design, which is the sort of candour worth noticing.

What we are not going to tell you. A date. EVX mainnet timing has not been publicly stated by the project anywhere we could find, and a date printed in a document you keep is a promise this handbook cannot source. The EVX whitepaper exists, it is dated June 2026 and credited to the BTX Development Team, and we have read it, but it is not published anywhere a reader can obtain it. Note also that BTX's own site does not currently mention EVX at all.

Two disclosures. easyBTX owns and parks a number of EVX-branded domains, including evx.cash, so we are not a neutral party on this subject. And the detailed analysis behind this section is in the research archive, where the sourcing is laid out at length.

The short version: EVX is a serious design, described in documents that are not public, with a narrow and currently dormant piece of it running on a testnet. Treat it as a plan you find credible or you do not, and not as infrastructure you can build on this month.

If you take one habit from this handbook, make it this one: when someone tells you what BTX does, go and look.

btx.dev is the project's own site, and the closest thing to a source of truth. It carries the documentation, the getting-started guides, the RPC reference and the specifications, in several languages. One caveat worth knowing: it can lag behind the code, and at the time of writing it presented a node version that GitHub had already moved past.

github.com/btxchain/btx is the reference node, in full, MIT licensed. This is where every rule in this handbook actually lives. You do not need to read C++ to get value from it: the release notes explain what changed and why, in unusually plain language, and the issue tracker shows what people are arguing about. If you want to check a single thing from this book, src/kernel/chainparams.cpp holds the constants: the 21,000,000 cap, the 20 BTX reward, the 525,000-block halving, the 90-second target and every activation height in section 8.

Two honest notes about the releases. The current release ships checksums but is not signed, and earlier releases were, so the signing stopped rather than never having existed. And a checksum proves the file matches what the publisher uploaded. It does not prove the binary matches the source, because these are not reproducible builds.

postquantum.wiki is the reference for the cryptography underneath: a cited, plain-language encyclopedia of quantum computing and the schemes built to survive it, including the NIST standards BTX's signatures are built on. Useful whether you want the one-paragraph version or the standards themselves.

btxscan.io is the block explorer, and it is where you check anything you have been told, including everything in this handbook.

A handbook that only lists good news is an advertisement. These are the things worth knowing before you spend electricity or attention.

• BTX has no established public market. Any price you encounter is either a model or two people agreeing privately. Treat anything you mine as uncertain, never as income.
• The network is small. On the day this was written the two working pools reported 53 and 670 connected workers between them, and nine of the machines on Byron Bay were Macs running easyBTX, which is the only client that reports its hardware. That is the honest scale of it today.
• BTX is transparent, not private, whatever the genesis message and the launch announcement say. Section 8 has the detail.
• Many nodes are not independently checking the work. Verification of the current proof-of-work needs capable hardware, and the current arrangement is documented by the project as temporary.
• Mining costs real electricity and runs your GPU hard, which means heat and power use, and roughly 6.5% to 8.5% of your mining time goes to fees before any of that.
• The easyBTX builds are not code-signed yet. That is why some antivirus engines flag them, and it is also why every build publishes a SHA-256 you can check yourself before you run it.
• Another coin uses the ticker BTX. If you search for a price you will probably find it instead of this chain.
• Back up your wallet. No part of this project can recover keys for you, which is the point of self-custody and also its cost.

None of that is a reason not to be here. It is the difference between arriving with your eyes open and arriving because somebody sold you something. BTX is a young chain doing an unusual and technically serious thing, run by people who mostly will not tell you their names, with no market, a small network and a lot left to build. If that sounds like a reason to pay attention rather than a reason to leave, you are probably in the right place, and you are certainly early.