Programmability on Bitcoin: Sidechains, Rollups, and BitVM

Sidechains: Liquid, Rootstock (RSK), and Stacks (sBTC)

Sidechains are independent blockchains that run in parallel to Bitcoin and enable features not available on the base layer. They rely on mechanisms to lock BTC on-chain and issue equivalent assets on the sidechain. These systems typically have their own consensus rules, virtual machines, and transaction logic.

Liquid Network

Liquid Network, developed by Blockstream, is a federated sidechain designed primarily for faster inter-exchange settlement. It allows users to peg-in BTC, which becomes L-BTC on the Liquid network. Transactions on Liquid are faster (1-minute blocks), confidential (using Confidential Transactions), and support token issuance for assets like stablecoins or securities. Liquid is governed by a federation of functionaries who sign blocks and manage peg-in/peg-out operations. While it offers high performance and privacy, its security relies on the honesty of the federation, not Bitcoin’s proof-of-work.

Rootstock

Rootstock (RSK) is a Bitcoin-pegged sidechain that provides full Ethereum Virtual Machine (EVM) compatibility. It enables smart contracts written in Solidity, allowing developers to build DeFi applications, oracles, NFTs, and more—using BTC as the base asset. RSK uses merge-mining with Bitcoin, meaning that Bitcoin miners can also validate RSK blocks. However, the peg mechanism is controlled by a federation, and any security assumptions about RSK depend on this intermediary set.

Stacks

Stacks, formerly known as Blockstack, takes a different approach. It uses Bitcoin as a settlement and anchoring layer, but maintains a separate chain for execution. In 2023, Stacks launched sBTC, a programmable BTC asset pegged 1:1 with real bitcoin. sBTC enables developers to write smart contracts using the Clarity language—a decidable, non-Turing complete programming model. Unlike Ethereum’s gas-based model, Clarity offers predictable computation and readable contract logic. Stacks is currently transitioning to its Nakamoto upgrade, which introduces faster block times and a new consensus layer to improve responsiveness.

Rollups on Bitcoin

Rollups are a category of Layer-2 protocols that bundle many transactions into a single proof submitted to the base chain. They are widely used on Ethereum, where they have enabled scalable DeFi ecosystems with minimal on-chain overhead. In a rollup system, the computation and data storage happen off-chain, while the settlement and proof verification occur on-chain. This allows rollups to scale throughput significantly while retaining some level of base-layer security.

Adapting rollups to Bitcoin has been challenging due to Bitcoin’s limited scripting language and lack of native support for verifying complex proofs like SNARKs or STARKs. Despite this, several projects in 2024–2025 have made major advances toward building Bitcoin rollups.

Citrea

Citrea, developed by Chainway, is the first zero-knowledge rollup designed specifically for Bitcoin. It leverages Bitcoin’s Taproot upgrade to anchor zk-proofs on-chain while executing transactions off-chain in a zkVM (zero-knowledge virtual machine). Citrea allows developers to write smart contracts and applications that are cryptographically verifiable but do not require Bitcoin nodes to process every step. Its design prioritizes integrity and modularity, aiming to support DeFi applications while settling natively to Bitcoin blocks.

BOB

BOB (Build on Bitcoin) is an EVM-compatible hybrid rollup that connects Bitcoin to an application layer built using Ethereum tooling. It combines OP-stack infrastructure with a native BTC bridge, enabling developers to use Solidity while still anchoring finality on Bitcoin. BOB emphasizes composability with existing Ethereum tools, making it attractive for multichain development. The challenge remains the trust assumptions around BTC bridging and validator set decentralization.

Botanix

Botanix, launched in early 2025, offers another EVM-compatible rollup for Bitcoin. It uses a novel architecture to anchor EVM-based transactions to Bitcoin while preserving fast execution on the rollup layer. Botanix proposes 5-second block times, integrated wallet infrastructure, and tools for liquidity provisioning. Its peg model allows BTC to be bridged into the rollup through a federation or smart contract-based custodian, depending on the deployment. Botanix positions itself as a Bitcoin-native environment for developers familiar with Ethereum tooling.

Bitcoin rollups remain an emerging field. None of the current implementations have the same trustless peg-in/out guarantees as rollups on Ethereum. Instead, they use hybrid models that rely on third-party bridges or time-locked redemption mechanisms. The lack of general-purpose verification opcodes in Bitcoin limits the extent to which zk-proofs or fraud proofs can be validated directly. Nonetheless, the ongoing research into primitives like OP_CAT, OP_TAPLEAF_UPDATE_VERIFY, or Covenants may eventually open the door to more trust-minimized rollup designs.

BitVM

BitVM is a recently proposed framework that enables Turing-complete computation on Bitcoin without changing its consensus rules. First described in 2023, BitVM leverages challenge-response protocols between two parties—called the prover and the verifier—to simulate arbitrary computation through a series of hashed commitments and conditional script paths. It uses Taproot trees and pre-signed transactions to enforce game-theoretic guarantees.

In practice, BitVM allows any computable function to be executed off-chain and verified on-chain, provided that at least one honest party participates in the challenge protocol. This opens the door to use cases like zero-knowledge proof verification, BTC-native bridges, and rollup validation.

BitVM differs from traditional smart contracts in that it does not run computation on-chain. Instead, it shifts all execution off-chain and brings disputes back to Bitcoin only when needed. This minimizes block space usage and preserves Bitcoin’s conservative design. However, it also introduces high latency and interactivity, making BitVM better suited for use cases like settlement validation, fraud detection, or conditional unlocks, rather than user-facing apps.

New Wave of Bitcoin Layer-2s: Merlin, B² Network, and Bitlayer

Beyond the established Layer-2 projects like Citrea, Stacks, and RSK, several new solutions have emerged in 2025 that aim to further expand Bitcoin’s programmability and scalability. Merlin positions itself as a Bitcoin-native Layer-2 optimized for DeFi applications, offering fast transaction finality, high throughput, and developer tooling designed to replicate the success of Ethereum’s dApp ecosystem—while settling trust and value on Bitcoin. By enabling EVM-compatible smart contracts and building in strong incentives for liquidity providers, Merlin is attempting to bridge the usability gap between Bitcoin and modern DeFi environments.

B² Network introduces a zk-rollup framework tailored for Bitcoin, bringing scalability and programmability through zero-knowledge proof systems. It offers EVM compatibility, allowing developers to reuse existing Solidity code while benefiting from the final settlement security of the Bitcoin base layer. The rollup uses recursive SNARKs to compress transaction data and support scalable verification, though like other rollups, it still relies on bridging mechanisms to move BTC between layers.

Bitlayer takes a more modular approach, branding itself as the first zkVM-powered Layer-2 on Bitcoin. It enables developers to write general-purpose applications with advanced cryptographic assurances and leverages Bitcoin as a settlement and data availability layer. Bitlayer aims to offer high flexibility in smart contract design, cross-chain messaging support, and compatibility with Ethereum development tools like Remix and Hardhat. While still early, Bitlayer is attracting attention for its potential to become a generalized Bitcoin execution environment.

Together, these projects represent a broader trend: the emergence of Layer-2 solutions that are not only scaling Bitcoin’s throughput but also turning it into a base for programmable, composable financial infrastructure. Each introduces different trade-offs in security, performance, and decentralization, but all signal a growing conviction that Bitcoin’s future can include complex applications—without compromising its foundational values.

Peg-in/ peg-out models, validator sets, and proof assumptions

All programmable Layer-2s on Bitcoin rely on some form of asset transfer between the base layer and the second layer. These transfers require pegging mechanisms that lock BTC on-chain and issue an equivalent representation off-chain. The integrity of this process is critical for user trust and protocol safety.

The most common model is the federated peg, where a group of signers manages a multisig wallet on Bitcoin. Users send BTC to this wallet and receive tokens (such as L-BTC or RBTC) on the sidechain. To withdraw, they send tokens back and the federation returns the BTC. This model is simple and scalable, but it introduces custodial risk. If the federation colludes or is compromised, user funds can be lost or frozen.

Some systems use smart contract-based pegs or hash-time locked contracts (HTLCs). These methods allow non-custodial bridging, but they are limited by Bitcoin’s script constraints. Rollups, for example, may rely on one-way pegs where BTC is sent into a locking contract and redeemed later through off-chain verification. Because Bitcoin cannot natively verify zk-proofs or fraud proofs, trust assumptions remain in external relays or validation servers.

Validator sets vary by system. Sidechains like RSK use merged mining and rely on the economic incentives of Bitcoin miners. Others use dedicated block signers, proof-of-authority, or even proof-of-stake mechanisms. The security and censorship resistance of the Layer-2 depend heavily on how decentralized and transparent the validator set is.

Proof systems also differ. Rollups may use zero-knowledge proofs (e.g., SNARKs) or optimistic fraud proofs. BitVM introduces a new class of interactive proofs based on computation challenges. Each method has trade-offs in terms of speed, verification cost, and user trust.

Developer ecosystems and tooling

Programmable Layer-2s are only useful if developers can build on them. As of 2025, the Bitcoin ecosystem has seen a surge in tooling to support smart contract development, asset issuance, and wallet integration.

Stacks provides the Clarity language, with predictable execution and native integration with Bitcoin blocks. Developers can build DeFi apps, NFT platforms, and DAOs using Clarity and deploy them with anchors to the Bitcoin chain.

RSK supports Solidity and EVM tools, enabling Ethereum developers to build on Bitcoin infrastructure with minimal friction. Projects like Sovryn and Tropykus have used RSK to bring lending, trading, and stablecoins to the Bitcoin ecosystem.

Citrea and Botanix aim to provide rollup SDKs that allow developers to build apps using existing Ethereum-based languages. This includes Remix integration, Metamask compatibility, and subgraph indexing for analytics.

BitVM-based tooling is still in early stages, but prototypes for compilers, dispute engines, and on-chain verifiers are emerging. These tools will be essential for building practical applications around interactive proofs or custom computation logic.

Infrastructure providers such as L2.watch, Chainway, and BOB Studio are building dashboards, bridges, and developer portals to support Bitcoin Layer-2 activity. As interoperability improves, developers will be able to create cross-chain apps that settle in BTC but leverage smart contracts and token logic from Layer-2s.