The Great Script Restoration could unlock powerful new ways to secure, transfer, and program Bitcoin. But its five-part proposal raises an uncomfortable question: can Bitcoin become dramatically more capable without sacrificing the simplicity that makes it so difficult to control?
Sixteen years ago, Bitcoin deliberately became less powerful.
Not less valuable. Not less decentralized. Not less resistant to monetary debasement.
Less programmable.
In the summer of 2010, Bitcoin’s early developers disabled fifteen operations in its native scripting language after discovering that certain computations could consume catastrophic amounts of memory and processing power. It was an emergency amputation performed on a live network. And at the time, it made complete sense.
Bitcoin was still a fragile experiment. Its network was tiny, its client software was immature, and its day-to-day survival was infinitely more important than supporting exotic financial contracts. A decentralized monetary system that can be crashed by a single clever calculation isn’t much of a monetary system at all. When forced to choose between expressive programmability and bulletproof survival, Satoshi Nakamoto and early contributors didn’t hesitate. Bitcoin sacrificed functionality for security.
Those fifteen operations were locked away in the protocol’s basement and never returned.
Until now, perhaps.
On November 6, 2026, Bitcoin developers Rusty Russell and Julian Moik presented an updated, comprehensive version of the Great Script Restoration, an ambitious blueprint designed not only to resurrect Bitcoin’s dormant programming capabilities, but to introduce several transformative new ones.
We are talking about far more than multiplying large numbers or gluing pieces of data together. If adopted, this proposal could fundamentally change how users build sovereign Bitcoin vaults, enforce recursive spending restrictions, architect Layer 2 payment networks, and construct cryptographic contracts that currently require clumsy, interactive workarounds. It even sketches out a viable path toward verifying certain post-quantum signature constructions directly inside Bitcoin Script.
Yet what makes this proposal truly fascinating isn’t the list of restored commands.
The developers aren’t simply proposing to flip a switch and turn those fifteen disabled opcodes back on. They are proposing an entirely new execution environment that measures, prices, and strictly bounds the computational cost of every single action a script performs.
Sit with that implication for a moment. Bitcoin could regain the capabilities it abandoned sixteen years ago, but only by introducing a consensus-level resource accounting system that charges a computational budget for every byte manipulated and every operation executed.
The engineering objective is clear: make Bitcoin dramatically more programmable without making a single block more expensive for an ordinary node to validate.
And that ambition forces us to confront a much deeper, much more uncomfortable set of questions.
What if Bitcoin’s strict programming limitations—originally introduced as emergency patches in 2010—accidentally became one of the primary reasons its monetary system is so resilient today?
What if expanding its scripting language alters not just what developers can build, but the economic incentives of the miners who decide which transactions get confirmed in the first place?
What if the real danger isn’t that a complex script crashes a Raspberry Pi running a full node, but that complex scripts make it financially lucrative for miners to reorder, censor, or manipulate the applications built on top of Bitcoin?
That is where the Great Script Restoration stops being just another technical pull request and becomes a philosophical crossroads. Because this debate isn’t really about fifteen dusty commands from 2010.
It is about what Bitcoin should become.
To grasp why the November 2026 proposal is such a watershed moment, we have to travel back to Bitcoin’s infancy.
From Genesis block onward, Bitcoin has always contained a built-in scripting language. Unlike traditional banking databases—or account-based blockchains—Bitcoin does not simply maintain a giant spreadsheet of user balances and ask whether Alice has enough funds to pay Bob. Instead, every Bitcoin transaction locks coins inside specific programmatic conditions, and every subsequent transaction must provide mathematical proof that those conditions have been satisfied.
At the most basic level, those conditions require a valid cryptographic signature corresponding to a public key. But Bitcoin Script was designed from day one to express far richer rules: multi-signature quorums, time-based locks, hash preimages, and branching logic where the same output can be spent through entirely different pathways depending on the circumstances.
In Satoshi’s original codebase, however, that scripting engine contained instructions that were far too dangerous to leave exposed on an open, adversarial peer-to-peer network.
Take OP_CAT, the opcode designed to concatenate—or glue together—two pieces of data on the stack into a single element. On paper, concatenating two byte strings sounds completely benign. Every introductory programming language does it in a single line of code.
Now think like an attacker. Imagine pushing a small piece of data onto the stack, duplicating it with OP_DUP, concatenating the two copies together with OP_CAT to double its size, duplicating the result again, and concatenating it again. Each pair of instructions doubles the memory footprint of the element on the stack. Repeat that tiny two-opcode sequence twenty times, and a single byte balloons into more than a megabyte. Repeat it thirty times, and a script measuring just a few dozen bytes in a transaction forces every validating node on the planet to allocate over a gigabyte of RAM.
Other early opcodes carried similar denial-of-service time bombs. Arithmetic operations on arbitrarily sized inputs could tie up CPU cores in expensive calculations. Bitwise shift operations like OP_LSHIFT and OP_RSHIFT could manipulate unexpectedly massive values. Substring extraction commands could slice and copy memory repeatedly without proportional limits. Worse still, Bitcoin’s 2010 implementation lacked any unified system for pricing or bounding the actual CPU and memory resources these instructions consumed relative to the size of the transaction.
In the summer of 2010, after high-profile vulnerabilities—including the critical bug tracked as CVE-2010-5137—exposed just how easily a maliciously crafted script could bring nodes to their knees, Satoshi intervened decisively.
The response was swift and surgical: disable the dangerous opcodes outright, clamp tight byte limits onto stack elements, and lock down the execution environment. Protect the network at all costs.
When the dust settled, Bitcoin had lost native support for string concatenation and slicing (OP_CAT, OP_SUBSTR, OP_LEFT, OP_RIGHT), bitwise logic (OP_INVERT, OP_AND, OP_OR, OP_XOR), bit shifts (OP_LSHIFT, OP_RSHIFT), and core arithmetic operations (OP_MUL, OP_DIV, OP_MOD, OP_2MUL, OP_2DIV).
To a casual observer, those look like obscure assembly-language minutiae. To a protocol architect, they define the exact boundaries of what financial agreements can be enforced trustlessly by Bitcoin’s consensus rules.
Without native multiplication and division, even basic proportional financial calculations become awkward or impossible inside Script. Without byte manipulation and concatenation, scripts cannot easily construct or verify data structures like Merkle branches on the fly. Without flexible transaction introspection, a script locking a Bitcoin output is completely blind to the structure of the transaction that is trying to spend it.
The trade-off made in 2010 was stark. Bitcoin became vastly less flexible as a programming environment, but its worst-case validation costs became simple, predictable, and easy to bound. For a nascent monetary network whose core value proposition depends on ordinary individuals being able to verify the entire ledger on modest consumer hardware, that trade-off wasn’t just reasonable—it was existential.
We should resist the temptation to rewrite history. Disabling those fifteen commands wasn’t a blunder simply because researchers sixteen years later have engineered clever ways to bring them back safely. It was a rational, disciplined response to the realities of 2010.
The real question today is whether Bitcoin can preserve that same security discipline while unlocking a vastly more capable design.
Why Bitcoin, stocks, and gold are fighting for scraps today, and how to position for the coming liquidity flood.
Whenever Bitcoin’s scripting capabilities come up in public debate, the conversation almost immediately degenerates into one of two caricatures.
One camp insists that Bitcoin is an inert pet rock—a digital spreadsheet incapable of doing anything beyond moving coins from address A to address B. The opposing camp panics at the mention of any new opcode, convinced that restoring basic arithmetic will instantly turn Bitcoin into Ethereum, complete with bloated state, broken DeFi protocols, and centralized validators.
Both caricatures miss the mark entirely.
Bitcoin already enforces sophisticated programmable spending conditions every single day. The Taproot upgrade, activated in November 2021, transformed how complex scripts work by allowing users to hide multiple spending pathways inside a Merkelized tree of scripts, revealing only the specific condition actually used when the coins move. Miniscript has given wallet engineers a structured, mathematically verifiable language for composing and auditing complex multi-signature, timelock, and recovery policies. And the Lightning Network relies entirely on native Bitcoin scripts, hash locks, and relative timelocks to settle millions of instant off-chain payments anchored to on-chain enforcement.
Yet Bitcoin Script remains intentionally, stubbornly constrained. It does not maintain a persistent global state machine like Ethereum’s Virtual Machine. It does not allow arbitrary programs to loop indefinitely. And crucially, a standard Bitcoin script cannot freely inspect the details of the transaction spending it.
That blindness creates a massive chasm between what is economically simple to describe and what is cryptographically possible to enforce on Bitcoin today.
Consider a straightforward personal security goal: you want to build an on-chain savings vault for your family’s long-term cold storage. You want the rules of the vault to state that whenever a withdrawal is initiated, the coins must sit in a mandatory 48-hour limbo state before they can be spent to an external address. If an attacker steals your primary hardware wallet and triggers a withdrawal, you want an emergency recovery key held in a separate location to be able to sweep those frozen funds back to a deeply secured cold address during that 48-hour window.
Economic logic? Dead simple. Every high-net-worth individual, family office, and sovereign Bitcoiner wants this exact setup.
Today, while you can approximate vault-like behavior using clever combinations of pre-signed transaction trees, ephemeral keys, and timelocks, doing so requires rigid setup ceremonies, inflexible withdrawal amounts, or interactive coordination. If you want a vault that is truly non-interactive, allows partial withdrawals of arbitrary amounts, and enforces its delay rules directly through Bitcoin consensus rather than pre-computed workarounds, current Bitcoin Script gets in your way.
Or consider a shared Bitcoin output controlled by ten different participants. With on-chain block space inherently scarce, allowing multiple users to share a single Unspent Transaction Output (UTXO) and transition its internal state safely without requiring all ten people to be online simultaneously to co-sign every single update would be a massive leap forward for self-custodial scaling.
Notice that neither of these examples asks Bitcoin to weaken its security model or print more coins. They ask Bitcoin to let users express stricter, more granular security rules over their own money.
The Great Script Restoration tackles this bottleneck head-on—not by bolting on one narrow, specialized opcode for vaults and another narrow opcode for payment channels, but by restoring a foundational set of general-purpose building blocks.
And that architectural philosophy carries profound implications. When you give engineers general-purpose building blocks, they inevitably combine them in ways the original designers never imagined. Sometimes that emergent creativity is the entire point. Sometimes it is the exact source of systemic risk.
The framework unveiled by Rusty Russell and Julian Moik on November 6, 2026, did not materialize overnight. The two researchers have been refining this architecture for years. An earlier four-part iteration was widely debated across developer mailing lists in 2025, and two of its foundational pillars formally received Bitcoin Improvement Proposal (BIP) numbers in March 2026.
The November 2026 update expands and matures the design into a cohesive five-part package intended to activate together as a single, unified soft fork.
At the heart of the architecture is a new Taproot script-leaf version: 0xc2.
This isolation mechanism is critical to understand. Existing legacy scripts, SegWit v0 scripts, and standard Taproot (0xc0) scripts remain completely untouched. The developers are not proposing to retroactively change the rules governing a single satoshi sitting in an existing wallet today. Instead, they are carving out a dedicated opt-in execution environment—designated by the 0xc2
leaf version—where a brand-new set of rules, capabilities, and resource limits apply exclusively to scripts that explicitly choose to use it.
Let’s break down how the five pillars of this proposal interlock.