Skip to content
Basis Desk
Bitcoin · 8 min read Last reviewed November 19, 2026

BitVM Explained: Smart-Contract Computation on Bitcoin

BitVM enables arbitrary, Turing-complete computation on Bitcoin without a soft fork by shifting program execution off-chain and enforcing fraud proofs on-chain.

Editorial oversight: Julian Mercer, Chief Editor
Neutral
BitVM Explained: Smart-Contract Computation on Bitcoin

Key points

  • BitVM enables Turing-complete smart-contract verification on Bitcoin using Taproot and hash locks without requiring consensus soft forks.
  • Computation runs entirely off-chain between provers and challengers; Bitcoin's blockchain serves strictly as an arbitration court for disputed steps.
  • Original BitVM models used NAND gate commitments in multi-round bisection games; BitVM2 refines this into non-interactive, permissionless SNARK chunk verification.
  • The primary commercial use case is trust-minimized bridges for Bitcoin rollups operating under a 1-of-N honest verifier assumption.

BitVM is a computing paradigm that enables expressive, Turing-complete smart contracts on Bitcoin without requiring changes to the network's consensus rules 1. Proposed by developer Robin Linus in October 2023, the model borrows the optimistic verification architecture used in Ethereum rollups and adapts it to Bitcoin's constrained Script language 1. By running computations off-chain and keeping on-chain activity limited to pre-signed fraud-proof disputes, BitVM turns Bitcoin into an arbitration settlement layer rather than an execution engine 1.

Historically, Bitcoin intentionally avoided complex, stateful programming languages to prioritize security, predictability, and decentralization 2. As institutional interest in decentralized applications and Layer-2 scaling solutions expanded, researchers faced a structural constraint: adding arbitrary smart contracts traditionally required hard or soft forks to introduce new opcodes or covenant rules 2. BitVM sidesteps this governance hurdle entirely, using existing tools—primarily Taproot, hash locks, and timelocks—to verify any computable program 1.

Understanding BitVM requires examining how it decomposes complex calculations into elementary digital logic, how interactive challenger-prover games resolve disputes, and how its newer iteration, BitVM2, refines the framework for scalable, trust-minimized bridges.

The Bitcoin Script Constraint

Bitcoin relies on Bitcoin Script, a stack-based, non-Turing-complete execution language designed deliberately without loops, unbounded recursion, or complex cross-transaction memory 2. Every node in the network must process and validate every transaction; unrestricted execution could expose nodes to denial-of-service vectors, such as infinite loops 2.

Because Bitcoin cannot run complex applications natively, developers previously had to build external platforms, such as sidechains or federated networks, which typically rely on honest-majority multi-signature committees to manage funds. These setups introduce custody trust assumptions: if a quorum of signers colludes, user funds can be stolen. True Layer-2 networks, such as optimistic or zero-knowledge rollups, require the underlying Layer 1 to independently verify transaction transitions or fraud proofs. Until BitVM, engineers assumed that verifying such state transitions on $BTC required new consensus opcodes 1.

BitVM challenges that assumption. Instead of executing arbitrary logic on-chain, it executes logic off-chain and uses Bitcoin Script exclusively to verify claims if a dispute occurs 1.

NAND Logic and Bit Commitments

At the core of the original BitVM design is the mathematical reality of universal logic gates: any digital circuit or computer program can be expressed entirely through networks of NAND gates (NOT-AND gates) 1. A NAND gate takes two binary inputs and outputs a zero only if both inputs are one; otherwise, it outputs a one.

To translate this logic into Bitcoin Script, BitVM employs bit commitments 1. A bit commitment is a cryptographic mechanism that forces a party to commit to a binary value—either 0 or 1—without revealing it immediately, while preventing that party from changing the value later 1. In Bitcoin Script, this is achieved using hash locks: a prover reveals one of two pre-image strings to represent 0 or 1. Once a pre-image is revealed on-chain, the prover's choice is permanently fixed 1.

BitVM groups these bit commitments into logic gate commitments. In the original proposal, each NAND gate requires a small Script snippet that inspects the two committed inputs and verifies that the committed output matches the truth table of a NAND operation 1. Because Taproot (activated via Bitcoin Improvement Proposal 341 and 342) allows transactions to commit to massive Merkle trees of distinct execution scripts (the Tapscript tree), a developer can organize millions of individual NAND gate scripts off-chain [1, 2]. Only the specific gate contested during an active dispute ever needs to be executed on the Bitcoin blockchain 1.

The Challenger-Prover Game

BitVM operates on an optimistic verification model between two roles: a prover and a challenger 1. The prover claims that a given off-chain computation was completed correctly and that a specific outcome is valid. The challenger monitors the computation and checks for discrepancies 1.

Under regular operation, the prover and challenger compute the program off-chain, agree on the result, and complete the settlement through standard Bitcoin multi-signature transactions. In this cooperative path, zero verification logic touches the blockchain, preserving privacy and minimizing transaction fees 1.

If the prover posts a false claim, the challenger initiates an interactive dispute on-chain. This dispute unfolds as a bisection game:

  1. The prover asserts the correctness of a program containing billions of execution steps.
  2. Rather than evaluating the entire program on-chain, the challenger asks the prover to bisect the execution trace—halving the contested execution path repeatedly over successive on-chain rounds 1.
  3. Within several rounds, the search space narrows to a single contested instruction or NAND gate.
  4. The prover must execute that single gate's script on-chain using their committed inputs 1.
  5. If the on-chain gate script reveals an impossible logic state (for example, inputs of 1 and 1 yielding an output of 1), the Bitcoin consensus engine invalidates the prover's claim, slashing the prover's pre-funded collateral and awarding it to the challenger 1.

This dispute process requires only a 1-of-N honest verifier assumption. As long as at least one challenger in the pre-defined group remains honest and active, a fraudulent claim can be detected and struck down 1.

A Worked Example: Off-Chain State Settlement

To understand the operational overhead of the bisection mechanism, consider an application verifying an execution trace of 1,048,576 ($2^{20}$) computational steps.

Assume the prover locks 10 $BTC as an operational bond in an optimistic bridge contract. The prover asserts that a state transition spanning all 1,048,576 steps is correct. A challenger detects an error and formally objects.

Rather than testing 1,048,576 operations on Bitcoin, the protocol divides the problem:

  • Round 1: The challenger demands the prover commit to the state at step 524,288 ($2^{19}$). The challenger identifies that the error is in the first half.
  • Round 2: The prover commits to the state at step 262,144 ($2^{18}$).
  • Rounds 3 through 20: The dispute proceeds sequentially, cutting the remaining trace in half at each step.

After 20 bisection steps ($\log_2(1{,}048{,}576) = 20$), the parties isolate the dispute to an exact transition between two single operations—for instance, between step 131,071 and step 131,072. The prover is forced to execute that single operation on-chain. If the prover's committed output contradicts Bitcoin Script execution rules, the dispute transaction defaults against the prover. The bridge cancels the settlement and transfers the 10 $BTC collateral to the challenger to cover transaction fees and provide an economic reward.

While mathematically clean, this classical BitVM design carries a major friction: the interactive game requires multiple sequential Bitcoin transactions spread across days or weeks, exposing challengers to liquidity locks and network congestion risks 3.

The Shift to BitVM2

To address the latency and coordination bottlenecks of multi-round interactive bisection, the research team introduced BitVM2 in 2024 3. BitVM2 alters the fraud-proof model by reducing the multi-round bisection game to a non-interactive, three-transaction process 3.

BitVM2 accomplishes this by breaking off-chain programs into SNARK (Succinct Non-Interactive Argument of Knowledge) verifiers, which are subsequently segmented into small chunks of Script 3. Instead of requiring repeated on-chain queries back and forth, the prover publishes their assertions in a single commit transaction. If an assertion is invalid, a challenger can directly disprove the assertion in a single response transaction containing the mathematical proof of error 3.

BitVM2 also shifts the bridge architecture from permissioned challenger pools to a permissionless dispute model 3. In the initial BitVM design, the participant set had to be established during the initial setup of the Taproot tree, requiring all prospective challengers to pre-sign transactions. BitVM2 introduces mechanisms that allow anyone to challenge a fraudulent claim, moving closer to the trust model of standard decentralized rollups 3. Researchers have also noted parallels between these off-chain covenant-like emulations and proposals using functional encryption covenants to bypass consensus upgrades.

Building Trust-Minimized Bridges and Rollups

The primary practical application for BitVM is constructing trust-minimized two-way asset bridges between the Bitcoin base layer and Layer-2 rollups [1, 3].

In a standard federated bridge, deposited $BTC is held by custodians. If the custodians sign a withdrawal transaction, the Bitcoin blockchain executes it without checking whether an equivalent balance was legitimately burned on the Layer 2. By contrast, a BitVM-powered bridge binds withdrawals directly to execution proofs 3.

When liquidity operators fulfill user withdrawals on the Bitcoin mainnet, they file reimbursement claims verified by the BitVM contract. Provers must post financial collateral to back their reimbursement assertions 3. If a bridge operator tries to withdraw user deposits without presenting a valid state root of the Layer 2, any challenger can run the BitVM verification script to seize the operator's bond and reject the withdrawal 3.

This setup allows the creation of optimistic rollups and zero-knowledge rollups on Bitcoin where security does not depend on majority consensus of a multi-sig, but rather on the mathematical assumption that at least one honest participant will submit a fraud proof if an invalid withdrawal is attempted [1, 3]. Users looking to understand how client-side verification interacts with native proofs can examine Bitcoin light clients and SPV designs.

Common Misconceptions

Misconception 1: BitVM is an upgrade or soft fork to Bitcoin. BitVM is not a Bitcoin Improvement Proposal (BIP) that requires miner signaling or a network hard/soft fork 1. It is an off-chain application architecture that utilizes tools already available on the Bitcoin mainnet today, primarily Pay-to-Taproot (P2TR), timelocks, and basic conditional hash checks [1, 2].

Misconception 2: Bitcoin nodes must execute heavy smart-contract calculations. Bitcoin full nodes do not compute smart contracts when using BitVM 1. Full nodes only process standard Bitcoin transactions, verifying cryptographic hashes and signatures. The intensive computation happens off-chain on computers operated by the prover and challenger 1. Only a microscopic fragment of logic (such as an individual NAND gate or a chunked SNARK segment) is verified by the blockchain, and only when a dispute occurs [1, 3].

Misconception 3: BitVM brings instant, fully trustless rollups to Bitcoin today. BitVM does not provide instant, trustless scaling equivalent to Layer-2 networks with native consensus verification opcodes. Early implementations face capital inefficiencies: bridge provers must front liquidity and post substantial collateral to underwrite settlement periods 3. Furthermore, if transaction fees on Bitcoin spike drastically, challenger transactions could theoretically be priced out of blocks during a dispute window, creating an economic vector that developers must mitigate through dynamic fee-bumping designs.

How This Connects to the Market

The development of BitVM marks a strategic shift in how developers approach capital deployment on Bitcoin. By demonstrating that Turing-complete execution verification is possible without changing base-layer consensus, BitVM provides an alternative to multi-year political battles over soft-fork covenant proposals [1, 3].

For institutional market participants, the evolution of BitVM2 serves as a testbed for whether native Bitcoin capital can participate in decentralized lending, synthetic asset issuance, and cross-chain liquidity without surrendering custody to centralized custodial bridges. Institutional adoption of BitVM-anchored rollups will depend heavily on capital efficiency: specifically, the ratio of collateral bridge operators must lock up relative to the volume of user transactions they process. Monitoring the deployment of initial production bridges, on-chain dispute activity, and transaction fee management under network congestion will determine if the paradigm can move from cryptographic proof-of-concept to production infrastructure.

Questions this story raises

Does BitVM require a soft fork or changes to Bitcoin's rules?
No. BitVM relies exclusively on existing Bitcoin functionality, including Taproot, hash locks, and timelocks activated in past network updates.
What is the 1-of-N honest verifier assumption?
It means the system remains secure as long as at least one participant out of the designated challenger pool is honest, online, and willing to challenge fraudulent claims.
What is the main difference between BitVM and BitVM2?
The original BitVM relied on a multi-round interactive bisection game across many on-chain transactions, whereas BitVM2 uses chunked SNARK verification to resolve disputes in three non-interactive transactions open to permissionless challengers.
Are full Bitcoin nodes burdened by running BitVM smart contracts?
No. Complex programs are computed entirely off-chain. Full nodes only validate standard signatures and hashes, executing a single discrete computational step only when a formal dispute is initiated.

References

  1. [1] BIP 341: Taproot: SegWit Version 1 Spending Rules — Bitcoin Improvement Proposals
  2. [2] BitVM: Compute Anything on Bitcoin — BitVM Project

Evergreen explainer written by Basis Desk's system and checked by an independent model pass for factual errors and advice language. Figures, fees and rules change — the references above are where to verify current specifics. Market figures marked "at the time of writing" come from live exchange data. Report an error: corrections@basisdesk.news · corrections policy.

The Daily Brief, in your inbox at 07:00 ET

Five stories, the numbers that moved, what to watch. Three minutes. No hype, no advice, unsubscribe in one click.

Not financial advice. Basis Desk publishes information, not recommendations. Crypto assets are volatile and you can lose what you invest.