Key Takeaways


Andrew Poelstra’s decade-long work on Simplicity, a formally verifiable, expressive yet finite smart contracting language, has reached a milestone with its launch on Liquid’s mainnet. Built from a handful of mathematically defined combinators, Simplicity enables provable correctness, static cost analysis, and advanced features like covenants, vaults, custom sighash modes, and zero-knowledge proof verification, all without sacrificing Bitcoin’s scalability or decentralization. By deploying first on Liquid, Blockstream can safely test and refine real-world applications before pursuing integration into Bitcoin, with Simplicity HL providing a Rust-like interface to make development more accessible.

Best Quotes

“Expressive yet finite, that’s a good way to put it. We wanted something you can formally reason about, where you can prove it does what you expect, without blowing up validators or breaking the fee market.”

“It’s insane how many surprising behaviors are lurking in Script, little accidents of how opcodes were bolted on over the years. Simplicity’s formal model saves you from that.”

“Ethereum introduced an expressive language, but validators can’t even know a transaction is valid without running arbitrarily long code. That’s a trade-off Bitcoin would never accept.”

“On Bitcoin, we’d be laughed out of the room without real-world usage first. Liquid lets us experiment safely, it’s our proving ground.”

“You could implement vaults, zero-knowledge proof verifiers, custom sighash modes, or dynamic fee curves, all in Simplicity, all with formal guarantees.”

“Every time someone new tries to write raw Simplicity, they end up making their own higher-level language. Simplicity HL is ours, it looks like Rust but compiles to formally verifiable code.”

“The answer to ‘should I pay attention to Simplicity?’ is finally yes. It’s live, it’s real, and now it begins.”

Conclusion

Simplicity represents a careful, security-first path to expanding Bitcoin’s programmability, avoiding the pitfalls of other smart contract platforms while enabling advanced, verifiable use cases. Launching on Liquid allows developers to explore its potential in a live environment, test integrations, and refine tooling, with the long-term goal of bringing its formally provable contracts to Bitcoin itself. If adoption grows, Simplicity could unlock powerful new capabilities while preserving the network’s core principles of decentralization, predictability, and trust minimization.

Timestamps

0:00 - Intro

0:11 - "Brief” rundown of simplicity

16:13 - Bitkey & Opportunity Cost

17:51 - Smart contracts on bitcoin vs Etheruem

30:18 - Unchained

30:44 - Why liquid first

51:04 - Dev tools

57:51 - Road to simplicity on bitcoin

1:03:34 - Economic concerns

1:12:15 - Oracle problems and final thoughts

Transcript

(00:00) But on Bitcoin, there's always this worry that a user of Bitcoin just hoping to move money around might write these simple programs. We're not there yet. Andrew Pra, welcome back to the show, sir. It's great to have you. Hey, great to be back. Like I said, I want to say it again. Congrats on getting Simplicity over the line.

(00:25) I know it's been a long almost a decade journey for Blockstream. Yep. Yeah, for sure. We uh we got it onto the the test network less than a year ago. That was a big deal. But this is our first production network with with real money on it that you can use simplicity now with real money, which is a pretty cool thing. Yeah.

(00:44) So, I guess for anybody out there who's either newer to Bitcoin, unaware of simplicity, why don't we give uh a background? I was going to say brief background, but I like your verbosity, verbosity, and you go deep on it. So, I'm not going to I'm not going to um give any false promises to the audience. We're about to get an in-depth uh history on simplicity.

(01:07) It really starts in 2012 when Russo Oconor sort of sketched the design and then you guys decided to really lean into it in Blockstream in like 2016, correct? Yep. Yeah, that's that's about right. Um I would even say it started a little before. How about this? I will try to be brief. I always I always say that.

(01:25) I don't know why I even bother saying it but I'll try to be brief. So uh at even before even before simplicity in 2012 there was uh Russell Okconor had been in the Bitcoin space. he showed up very early days uh 2010 I think maybe 2011 I think it was 2010 and he had this concept called mast merkelized abstract syntax trees and this eventually turned into what uh is now tap routt where the idea is that rather than having a script system where you've got like if this then that kind of thing everybody runs this everybody has to download this whole program and then run it and then they've got various conditions that that

(02:01) apply under different conditions But they they've always got to download it, right? They've always got to see the whole script. What if instead every time there was a conditional, if this thing, then that thing, what if we put them all in a Merkel tree? And so now you can have um hundreds or thousands or millions of conditions.

(02:20) And when you want to spend your coins at the time of spending, you know which conditions you're going to use to spend the coin. So you just reveal that specific one. And the premise behind a Merkel tree is is you can do exactly that.

(02:37) It's this big structure where you can commit to arbitrarily large numbers of things um like up to up to billions before you're you're spending too much compute time on it. And then if you only want to reveal one of those billions of things, you have an overhead. You reveal the one thing and then you have an overhead of, you know, some some fixed cost, maybe like a kilobyte or something.

(02:57) uh versus having an overhead of revealing a billion different things which is what you'd have to do in the traditional model of script where the way you handle branches by having a bunch of if then statements and everybody's got to download the whole thing. So in tap routt we have that we have what's called the tap tree.

(03:16) You've got all these different scripts you can have if you want to do like a five of 10 multi-ig for for some reason. Um, one way you can do that is by taking all of the uh 10 choose five possibilities that you might have as a number of a couple thousand.

(03:34) Put them all into their own little tap branch and then whichever five participants you happen to have at the time of spending you you uh take the branch corresponding to those. So this is an idea from 2010 2011 again like the very early days that eventually made it into tap routt much much later of course and simplicity kind of came out I promise this is relevant to simplicity. So the premise behind simplicity is what if we took that idea and we we really went to the extreme with it.

(03:59) So one big thing that simplicity has well first off simplicity is the way that it fits into Bitcoin and the way that it fits into liquid is as basically a drop in replacement for Bitcoin script or the drop in replacement for tap script as as it is now.

(04:16) So you've got a tap tree, you've got all these different scripts and rather than using the existing Bitcoin script system, you use simplicity instead. Okay. And within simplicity you have these branches and these conditionals, right? So if if this person is available to sign then check his signature otherwise check this other signature or if the coin is old like past a certain age then allow these backup keys to be used or what whatever conditionals you might want then okay you've got these conditionals you you reveal whichever side that you actually take that's cool that's there's some efficiency there simplicity goes one

(04:49) step further and it says well conditionals are one way of composing two pieces of code or two programs, right? You've got uh some some sort of flag, some something that makes you decide what to do. And you've got these two things that you might do. And based on your flag, you pick one. Okay? And you can compose things in other ways. You could say, I've got these two programs. I want to run them both in a row.

(05:16) Bitcoin script is really good at this. What's called a concatenative language. You have a program, you run it, you just stick the other program right after, and you you run them. You run them in order. uh you might compose them by running both of your programs in parallel like on the same input and then somehow you you combine their outputs.

(05:33) There's there's a couple other things you might do. And it turns out that you can start with two different programs. One of them does nothing. It takes an arbitrary input and throws it away. And the other does nothing. It takes the arbitrary input and just passes it along.

(05:53) And you take those two programs arbitrarily many copies of them and you compose them with each other and other compositions and you can build up any any computation. This is this is something called the um the sequent calculus if you're into uh computer science or like historical computer science even. Uh it turns out you can build any computation just using these these um these two basic functions and these combinators.

(06:17) And that's the premise behind simplicity is that rather than having an opc codebased language where you have in Bitcoin script you know 70 or 80 op codes they all do different things. Most of them uh see the bulk of them just push things onto the stack but then there are others that can duplicate items. There are others that can compare them for uh to each other compare them to true or false uh do branches based on them.

(06:42) Uh, and then the