Timechain
Search Donate
Sponsors
Cake Wallet, private Bitcoin and Monero walletSideShift.ai, no-signup crypto exchangeOrangeRock, non-custodial bitcoin spot and perps tradingBraiins Hashpower, buy and sell Bitcoin hashrateLayer Two Labs, drivechains for Bitcoin
S16 · E37 · 1:38:53

S16 E37: Andrew Poelstra on Simplicity, Bitcoin Smart Contracts & Upgrades

6 Aug 2025 · by Vlad Costea · 12 min read
Published at block 908,891
Cover art for S16 E37, Andrew Poelstra on Simplicity, Bitcoin Smart Contracts & Upgrades
MP3 (136 MB)

The audio keeps playing while you browse the site.

Read the transcript16,629 words, every line links to the minute it was said

Ask this episode

Embed this episode

Paste this on your site or blog. It is a small player that streams from here: no trackers, no cookies, no ads.

Preview the player

I opened the show by calling Andrew Poelstra the CEO of Blockstream, and he had to stop me. "director of research," he said. I had the title wrong and the guest right, which is a fair summary of how most of my prep goes. He has spent fifteen years in Bitcoin, co-authored the 2014 sidechains white paper, and now runs research at Blockstream, where the thing on his mind was Simplicity, a smart contract language that had just gone live on the Liquid network.

The recording was remote, a little under an hour and forty minutes, and I went in with two jokes ready. One was that the project's tagline fits on a T-shirt (it came up again later, and the T-shirt turns out to be literal). The other was that Simplicity and Solidity rhyme, which Andrew took as a cue to explain exactly how the two relate. Between those, we covered covenants, a STARK verifier, Satoshi's disabled opcodes, a pun that exists only in French, and why he does not want Simplicity in Bitcoin before the 2030s.

Simplicity Is Live, With Real Money on It

Andrew called the launch "a pretty big milestone for us to have Simplicity launched and usable on a network with real money on it." The network in question is the Liquid Network, and he was quick to say that Liquid is not some exotic beast: "it's still the good old Elements." It is a fork of Bitcoin Core, built on the Elements Project, and the feature list as he gave it is short: "we've got multiple assets, we've got confidential transactions, we've got various script extensions, and now we have Simplicity."

I asked for the plain description of what Simplicity is. "Simplicity is a super low level, very machine focused," he said, and a few minutes later he added "It's really not designed for people." The language is "built out of these nine basic combinators," and the minimalism goes far enough that "We don't even have a first class notion of a bit in Simplicity." I had been picturing something you could sit down and write contracts in, and he took that picture apart pretty fast.

What you do write in is Simplicity HL, the human-facing layer. It is, in his words, "a response to Solidity is sort of where we're at," and the design goal is that it "should compile as Rust" (he put it as a syntactic subset: "It's like Rust."). A program written there becomes one big function. "So what you're really doing when you write Simplicity HL is you're building up a single function which is evaluated by the Simplicity interpreter," he explained, and the outcome of evaluating it is binary: "Either it aborts or it doesn't."

He demoed a minimal contract for me. "So it's one line of code, but it's cool to demo." As for whether a normal person can use any of this today, his answer was "If you're willing to go to GitHub and download stuff and kind of tape it together yourself, that's something you can actually use today, which is pretty cool."

What Satoshi Switched Off in 2010

Before Simplicity made sense to me, I needed Andrew to walk through why Bitcoin Script is the way it is. The original script "had all sorts of stuff that modern Bitcoin Script does not," he said. "It had OPCAT, famously, but it had multiplication." Then, in August 2010, "Satoshi disabled a whole bunch of this," after bugs turned up in the opcodes.

One of those bugs is my favorite, and he laid it out step by step. There was "in fact no limit on the size of elements that you can work with in the original Bitcoin Script," so you could duplicate an element and concatenate it with itself over and over. "You do that 64 times, right? And now you've got two, two to the 64, which I think is 16 trillion trillion or something, uh, bytes" and a node that tried to hold that in memory would simply fall over. The same kind of arithmetic mattered in his other story from that era: Andrew once earned free bitcoin from a Coinbase bug bounty by finding places where the Bitcoin Ruby interpreter disagreed with Bitcoin Core.

Today, he said, "script today can do basically three things." What it cannot do is let anyone think clearly about it. "you really can't reason about it despite being such a simple language that can't do a whole lot of things." He could "probably spend the whole hour just trying to describe all the weirdness about the lock times," and there are odder corners still, like the handling of negative zero.

I asked whether the language had always been this shaky. He pointed at a comment in the old code, "run forth where fools dare to tread," which he likes ("I like that comment"), and said the grief that followed was not a surprise to anyone: "The problems that we've seen since then were predictable and were predicted."

Covenants as a Side Effect

Covenants came up through OP_CAT, naturally. Andrew's explanation of why concatenation creates them is the cleanest I have heard: "This is why OP_CAT creates covenants, because cat itself is a pure function." Simplicity gets there by a more direct road: "we went one further, and we directly added transaction introspection." The outcome, as he summarized it, is that "Simplicity can do any computation, and it can do covenants." He framed the expressiveness in terms of computability: "any program that you can run in finite time that just manipulates pure data, Simplicity can express."

I pressed him on whether every flavor of covenant debate we have had on this show is moot once Simplicity exists. He did not go that far, but he did say that something like fee-rate calculation falls out of introspection naturally, and one idea he returned to later is signing a transaction "in a way where third parties or somebody who you delegate to can bump the fee, but can't otherwise change the transaction." The pain he was describing is familiar to anyone with a cold storage setup: "If you take your cold keys out and sign a transaction and then later wants to change that transaction in some way, you've got to take your cold keys out again to do it."

He and I had gone through this territory before, in S15 E17: Andrew Poelstra on Bitcoin Covenants (OP_CAT vs OP_CTV), and he also mentioned that he "was part of the Collider Script paper." That is the same research I covered with Avihu in S15 E65: Avihu M. Levy on ColliderScript, Covenants Without Soft Forks & Bitcoin's Research Renaissance. The trade-off Andrew drew from it was about cost: "with Simplicity, everything will be possible, but you might need a soft fork to make them economical." His own number for the colliderscript approach was "$50 million in electricity."

A Rocq by Any Other Name

Simplicity has been implemented in several places: C (verified with CompCert), Haskell, Rust, and Rocq. That last one prompted the best digression of the show. "It used to be called Coq for various historical reasons," Andrew said, and he went on to explain the French pun. "So they chose the word Coq, which in French means rooster, but of course in English means dick, as the name of there." The proof assistant is now called Rocq, formerly Coq.

The reason it matters for Simplicity is that "you can produce machine checkable proofs that your code will do what you expect of it." The language is small enough that this is realistic. He told me that he once wrote an implementation from scratch, "I literally, as I said, I did it off the shirt once without even, uh, reference to any of the other implementations," and the T-shirt line I had joked about at the top was apparently a literal description of the spec. In his words, you could "implement them off of the t-shirt."

He contrasted this with C++ and the way Bitcoin Script was born. One of the disabled features "would have made Bitcoin transactions easy to forge," and the quirks are "just like an accident of C++ turning into a weird thing." Rewriting consensus code is, for much of the Bitcoin community, "basically culturally forbidden." A language with formal proofs and independent implementations sits at the opposite end of that culture.

A STARK Verifier Inside Simplicity

The demonstration of what the language can carry came from StarkWare. They built a full STARK verifier on Simplicity, one that checks proofs of Cairo programs. That is a lot of computation to run inside a script language, and the practical question is how it stays fast. Andrew's answer was jets, which are "chunks of Simplicity that can be wholesale replaced with optimized C code." The speedup he described is dramatic: "do it in a couple hundred nanoseconds instead of a couple minutes."

I wanted to know about resource limits, since the opcode-explosion stories had put me on edge. Simplicity uses a byte-based cost model similar to Bitcoin's, and he does not want validators dealing with more than one dimension of cost. "You really don't want validators or developers to have to think about two dimensions, you don't want to have to think about your CPU and about your memory usage at once." Programs "vary wildly in what resources they use," but the design aims to keep the thing a developer optimizes down to a single property: "There's one property you need to optimize, which is the size of your transaction."

I asked him to size this against the Ethereum world, since STARKs and rollups are the usual talking points there. On Citrea, the ZK rollup design: "I think it's a super cool project." About optimistic rollups generally, he was more guarded: "but hey, optimistic roll-ups are a hell of a lot better than wrapped Bitcoin that are sitting on the Ethereum chain."

"It Feels Like Writing JavaScript"

My blunt pushback was whether Simplicity showed up too late. Ethereum has had years of developers, tooling, AMMs, and everything else. Andrew's answer: "I'm going to say no, it's not too late because it was never really easy to do that." On the timeline he added, "So you could argue that Simplicity has been happening for well over 10 years." And as for the boat: "I don't think that we missed a boat."

He was not shy about why building on Ethereum became easy. "It feels like writing JavaScript," he said, and the audience for that was "the kind of like YOLO reckless people who were attracted to Ethereum." Building on Liquid with Simplicity is "definitely possible, but it's going to be so much harder than it was to build on Ethereum." Part of the reason is the cost of correctness: "Your thing's not going to be able to even get off your own computer until you've answered a lot of questions that in Ethereum you can kind of just shrug and say, well, the miners will answer that."

He did not expect a stampede, either. "I don't imagine that the kind of people deploying AMMs today are going to be like looking at Simplicity and then deploying an AMM next year." And on the idea that Simplicity would rewire how people write Bitcoin policies: "Simplicity itself is almost impossible for a human to write directly," while "I don't think Simplicity is going to cause a lot of shakeups." The interesting terrain for it, he said, is "pulling apart signatures and applying constraints to them," with "complex enterprise policy kind of things" better handled by tools built for that.

Drivechains and Incentives Outside Bitcoin

I wanted his take on drivechains, something Paul Sztorc has argued for at length on this show. Andrew is wary. "and that makes me a little nervous," he said of the incentive structure, and the concern as he described it is that a miner chain reorganization could be used to steal pegged coins. The skepticism, he said, comes "largely from Peter Todd," and for the sidechain design he added "for both the drivechain and probably more importantly for Bitcoin, you really don't want to have these kinds of incentives present."

I challenged the incentive argument and he went along with the analogy I offered ("That's a good analogy") before laying out his framing: this is "an attempt to predict human behavior in the presence of incentives that are different, depending on which layer you look at it." The danger he named was to "build incentives outside of Bitcoin that will wreck up the incentives of Bitcoin."

He had also been rethinking extension blocks. I asked if they might have been the way, and he said "Maybe it was," then added "My view of extension blocks has certainly soured over the years in which we've thought about them." There is a gap between what drivechains need and what he is willing to accept. Where he sits is clear: put the expressiveness in a language where behavior can be checked, and be careful with ideas that change who gets paid for what.

Miniscript, Quantum and the 2030s

The miniscript story was his example of how slowly adoption moves in Bitcoin. "It took several years for people to even start using it at all." The users he named: Ledger, Liana, AnchorWatch, and Specter. (I also spoke to Kevin Loaec in S15 E9: Kevin Loaec on Liana Wallet, Miniscript & Hardware Wallets.) He also told me about an instance where their new miniscript compiler beat Blockstream's own hand-optimized Liquid multisig script, which I take to be a good argument for letting machines write scripts.

On quantum, he was direct that the cost is real. "It's a huge, long term, expensive project to do," he said, while noting that "we could just have people using quantum-hard signatures today" if a chain were willing to pay for it. Andrew's observation about where Simplicity fits is "these kind of little things at the edges of the frontiers of Bitcoin Script development."

The timeline question I saved for the end, because I suspected the answer. "I'm not proposing Simplicity right now in this podcast as something we should get into Bitcoin." And just to be unmistakable: "not a chance is it going into Bitcoin this year or next year or this decade." His pitch for the long run is deliberately modest: "I would submit that you should like Simplicity or you should hate Simplicity less than other proposals."

On privacy coins I asked what he watches. "Monero and Zcash are the first to come to mind," he said, and what he likes about them is "dead simple cryptography" in one case and in another a project that "was also pretty cool technologically." He did not want a tail emission copied into Bitcoin: "I don't think it makes sense to have an infinite issuance. An infinite tail emission in a world where Bitcoin already exists as a finite supply." As for new Simplicity news, he said "maybe they haven't done it yet" about one of the ideas, and for project updates he pointed to simplicity-lang.org as "probably the number one resource and that's where we'll be posting updates."

There was a side conversation, too, about US states requiring ID verification for adult websites, which Andrew and I agreed is a mess, and I plugged my sponsors with the line "But before that, I gotta plug some sponsors." The T-shirt, the rooster, and the 2 to the 64 bytes stayed with me longer than the sponsors did, though. Andrew's spec fits on a shirt, he can write the language off it from memory, and the first thing on air that he fixed was my idea of who runs his company.

Listen to Andrew Poelstra on Spotify, Apple Podcasts, YouTube, and More

Time stamps:

  1. 00:00:50– Introducing Andrew Poelstra
  2. 00:01:45– Simplicity: Now Live on Liquid
  3. 00:02:12– Elements and Liquid’s Technical Evolution
  4. 00:03:09– Is Simplicity a Response to Solidity?
  5. 00:05:40– Simplicity’s Programming Model & Rust Inspiration
  6. 00:08:04– Demo Applications and Simplicity Playground
  7. 00:10:03– Why Not Stick with Bitcoin Script?
  8. 00:11:48– Bitcoin Script’s Limitations and Quirks
  9. 00:19:14– Simplicity’s Capabilities: Computation & Covenants
  10. 00:22:26– Formal Verification and Multi-Language Implementations
  11. 00:25:21– Machine-Checkable Proofs and Contract Safety
  12. 00:29:07– Covenants, OP_CAT, and Script Extension Fears
  13. 00:33:26– Simplicity as a Future Script Extension Path
  14. 00:34:31– Ethereum’s Design Mistakes & Simplicity’s Approach
  15. 00:53:00– Simplicity’s Lateness and Ethereum’s Rise
  16. 01:01:12– Simplicity’s Usability and Adoption Challenges
  17. 01:04:18– Potential Use Cases for Simplicity: Vaults, Business Logic, Quantum Signatures
  18. 01:08:06– Wallets and Simplicity Integration
  19. 01:16:30– Simplicity vs. Soft Forks for New Opcodes
  20. 01:19:01– Jets: Optimizing Simplicity with Native Code
  21. 01:22:44– Collider Script and High-Cost Emulation
  22. 01:24:44– Resource Limits and Transaction Size
  23. 01:29:34– Non-Scammy, Technologically Interesting Altcoins: Monero, Zcash, Grin, and Sia
  24. 01:33:14– Where to Learn More About Simplicity

Verify this episode

This is the SHA-256 fingerprint of the MP3 as published here, timestamped in the Bitcoin blockchain with OpenTimestamps. If one byte of the file changes, the fingerprint changes.

SHA-256
2f77cc87b0dab09460ac388d9f1c0f0ad295a19e48f852d9ba886a89921c44d6
Proof
2025-08-06_s16_e37_andrew_poelstra_on_simplicity_bitcoin_script_upgrades.mp3.ots · all episode hashes (proof)
Status
Anchored in Bitcoin block 974,312
Timestamped
After release. The episode came out on 6 Aug 2025, but this proof was made on 3 Nov 2026 and anchored in block 974,312, so it proves this exact file existed by 3 Nov 2026, not on the release date.
How to check it yourself
  1. Download the MP3 and the proof into the same folder.
  2. Run sha256sum 2025-08-06_s16_e37_andrew_poelstra_on_simplicity_bitcoin_script_upgrades.mp3 (on a Mac: shasum -a 256 2025-08-06_s16_e37_andrew_poelstra_on_simplicity_bitcoin_script_upgrades.mp3). The result must match the SHA-256 above.
  3. Install the OpenTimestamps client (pip install opentimestamps-client) and run ots verify 2025-08-06_s16_e37_andrew_poelstra_on_simplicity_bitcoin_script_upgrades.mp3.ots. It hashes the MP3 again and checks the proof against your own Bitcoin node, then prints the block and the date the file existed by. Without a node, ots info 2025-08-06_s16_e37_andrew_poelstra_on_simplicity_bitcoin_script_upgrades.mp3.ots shows the block height to look up in any block explorer.

Share: X · Email · Link

Related

Comments

Comments run on my own server. No trackers, no tracking cookies.

0:000:00