Roughly two years after receiving the first Bitcoin transaction from Satoshi, Hal Finney wrote that Bitcoin cannot scale to have “every single financial transaction in the world” broadcast and included on-chain, and that “there needs to be a secondary level of payment systems” that is “lighter weight and more efficient”.
Since 2009, there have been repeated attempts to build a “better Bitcoin” by changing the constraints Bitcoin refuses to change: larger blocks, faster blocks, richer scripting, different governance, or different trust models (often trading open-ended decentralization for throughput).
Many of these systems shipped features earlier than Bitcoin could, but they did not converge on Bitcoin’s combination of (1) large-scale permissionless validation, (2) high-cost base-layer security, and (3) sustained global adoption.
Bitcoin has retained the largest share of total crypto market value for long periods and it continues to operate with a very large set of reachable full nodes distributed across many jurisdictions (Bitnodes currently shows ~25k reachable nodes), and its proof-of-work security budget is observable in the network hashrate tracked by major data sources.
In more recent years, the work shifted toward building layers that inherit Bitcoin’s properties rather than trying to outcompete them. But these attempts to scale Bitcoin have each come with their own custody trade-offs.
"It seems true that many users will have to rely on third-party, custodial services, which would act like banks. Bitcoin itself cannot scale to have every single financial transaction in the world be broadcast to everyone and included in the blockchain." - Hal Finney in 2010
It was previously thought that second layers would inevitably need to be custodial. Such layers can scale payments and bring other functionality to Bitcoin, but they change the security model, conflicting with Bitcoin’s core benefits:
In other words, these layers require trusting a third-party.
But in recent years, theoretical advancements made it apparent that trust-minimized, non-custodial second layers were in fact possible. However, there was a large gap between the theory and what was needed to actually make them work, especially at scale.
This is the core gap that GOAT Network has spent 3+ years trying to close: how to get Bitcoin second-layer throughput and programmability without custodial trade-offs.
Over the last decade, the industry has converged on “zero-knowledge proofs” as a scaling primitive: if you can prove “this large batch of state transitions was executed correctly” with a succinct proof, the base layer only needs to verify the proof and a small amount of accompanying data. But early proving systems were too slow, too expensive, and too operationally brittle for high-throughput production workloads.
Only recently - driven by major improvements in proof systems, prover implementations, hardware acceleration, and recursion/aggregation techniques - has ZK become fast enough and cost-efficient enough to serve as a general scaling layer at meaningful scale.
But even exponential advancements in zero-knowledge systems haven’t been enough to scale Bitcoin. Its script is too constrained to natively verify general-purpose validity proofs, so the “standard” Rollup recipe from other ecosystems doesn’t work. At least not directly.
That is why early Bitcoin scaling attempts have gravitated toward custodial or semi-custodial overlays in one form or another.
If Bitcoin can’t cheaply verify general-purpose validity proofs, the remaining path is to make the base layer enforce correctness in a different way: by providing a mechanism to verify disputed claims under Bitcoin’s existing rules.
In December 2023, Robin Linus published BitVM: Compute Anything on Bitcoin. BitVM proposes a paradigm where arbitrary computation is performed off-chain and only verified on Bitcoin via an interactive challenge process, explicitly drawing an analogy to Optimistic Rollups:
“BitVM is a computing paradigm to express Turing-complete Bitcoin contracts. This requires no changes to the network’s consensus rules. Rather than executing computations on Bitcoin, they are merely verified, similarly to optimistic rollups. A prover makes a claim that a given function evaluates for some particular inputs to some specific output. If that claim is false, anyone can perform a fraud proof and punish the prover. Using this mechanism, any computable function can be verified on Bitcoin.” - bitvm.org
That shifted the question from “can we change Bitcoin consensus to natively verify ZK proofs?” to “can we design an economically viable dispute mechanism that Bitcoin can enforce?”.
But BitVM was not a deployable blueprint for a public bridge or a real L2. The initial design is explicitly limited to a two-party prover/verifier setting, and it requires significant off-chain computation/communication and large pre-signed transaction structures.
In other words: the enforcement concept was there, but permissionless participation, bridge-specific flows, and operational practicality were not yet solved.
In 2024, Linus and collaborators published BitVM2: Bridging Bitcoin to Second Layers. BitVM2 narrowed the design toward the bridge/settlement problem and made two key upgrades:
Shortly after the release of the paper, the BitVM Alliance was formed, bringing the top engineering teams in the Bitcoin-scaling ecosystem together to work on BitVM2 - including the GOAT Network development team.
But it soon became apparent that BitVM2 still wasn’t practical for real-world deployment at scale. The BitVM2 paper itself frames dispute resolution in week-scale timeframes (“no more than 2-3 weeks”), and the approach can require large on-chain transactions during disputes because the verifier logic is split into large sub-program chunks.
Since the dispute cost, dispute latency, reimbursements, and incentives must all work under real-world adversarial conditions, a major gap still existed.
Building on the garbled-circuit direction introduced by Jeremy Rubin (Delbrag) and extended by Liam Eagen (Glock), GOAT Network released the GOAT BitVM2 White Paper in January 2026, specifying a BitVM2 settlement design optimized for zkRollups, including a dispute path that represents the verifier as a garbled circuit and uses a designated-verifier SNARK to keep worst-case enforcement economically viable on Bitcoin.
The target is a Bitcoin-native second layer with:
GOAT BitVM2 adds protocol work on operator behavior, challenge economics, and liveness - addressing issues such as operator double-spend risk, challenger reimbursement/incentives, and missing or weak incentive structure - via mechanisms including a redesigned challenge process and an on-chain sequencer-set commitment scheme.
Essentially, we’ve taken BitVM2 as the base primitive, then engineered it into a Rollup-grade settlement path where the enforcement game is short enough and economically sane enough to use under production constraints.
GOAT BitVM2 is the settlement component of a complete zkRollup stack. The rest of the stack is built to match that settlement model end-to-end:
The result is a fully integrated stack built end-to-end, where execution, proving, sequencing, and settlement are designed and maintainable as one complete system, enabling:
For the first time, we have a route back to the original system objective: peer-to-peer financial activity without custodians, at scale, with an enforcement boundary that still resolves under Bitcoin consensus.
GOAT BitVM2 is currently in Testnet. For details on how you can get involved, visit: goat.network/blog/bitvm2-genesis-pioneer-campaign-phase-1---cross-chain-explorer
.png)
