High-Assurance
Bitcoin Contracts

Simplicity is a next-generation smart contracting language for Bitcoin, designed for verifiable security, financial correctness, and high-value applications.

Why Simplicity?

Don't Trust Your Code's Security. Verify it.

Every major financial market depends on correctness. But the multi-billion dollar failures of the past all relied on hope. Simplicity is the only smart contracting language to offer certainty by allowing developers to mathematically prove exactly how a contract will behave before it's deployed.

No more economic exploits
No more re-entrancy and logic bugs
Predictable resource costs
High-assurance smart contracts for Bitcoin

How Simplicity Works

Verifiable, Predictable Execution.

Simplicity complements Bitcoin Script with a low-level language that's expressive enough for advanced covenants and financial instruments while being formally verifiable for absolute predictability. Developers write SimplicityHL, full nodes execute Simplicity. Learn more

IDEExample
sig := const 0xe907831f80848d1069a5371b402410364bdf1c5f8307b0084c55f1ce2dca821525f66a4a85ea8b71e482a74f382d2ce5ebeee8fdb2172f477df4900d310536c0 : 1 -> 2^512
pk := const 0xf9308a019258c31049344f85f89d5229b531c845836f99b08601f113bce036f9 : 1 -> 2^256
msg := const 0x0000000000000000000000000000000000000000000000000000000000000000 : 1 -> 2^256
in := pair (pair pk msg) sig : 1 -> 2^512 * 2^512
out := jet_bip_0340_verify : 2^512 * 2^512 -> 1
main := comp in out

Easy to Write

Simplicity isn't just powerful—it's fun! If you know Rust, you already know Simplicity. It's straightforward, no steep learning curves.

Easy to Read

No more complicated, messy scripts. Simplicity makes covenants and conditions clean, clear, and easy to understand.

Easy to Run

You write in SimplicityHL, your full node runs Simplicity. It's that easy—elegant code, simple execution.

Your Smart Contracts Deserve Better

Ethereum
Simplicity
Predictability
No

Gas costs can spike, inviting expensive runtime surprises.

Yes

Resource costs are fully bounded and known before execution.

Correctness
No

Hard to prove safe, meaning hacks are frequent.

Yes

Formally verifiable — mathematically prove contract behaviour.

Security
No

Lots of components; large attack surface.

Yes

Minimal trusted codebase; drastically reduced attack surface.

Design Fit
No

Ambiguous and unfocused "world computer" claims.

Yes

Purpose-built for Bitcoin — covenants and financial instruments.

Real-World Applications

What can you do with Simplicity?

Covenants
Covenants
Zero-Knowledge
Proofs
Zero-Knowledge Proofs
Prediction
Markets
Prediction Markets
Lending
Tools
Lending Tools
Liquidity
Pools
Liquidity Pools
Trustless
Swaps
Trustless Swaps
Distributed
Exchanges
Distributed Exchanges

High-Assurance Financial Programming

Since Simplicity contracts are auditable and proveable before deployment, Simplicity offers unprecedented transparency and compliance assurance for financial institutions. Build programmable capital markets, issue assets, and settle trades—all on Bitcoin's most secure sidechain, Liquid.

High-Assurance Financial Programming illustration

Testimonials

Simplicity’s strength comes from deep, foundational principles in type theory. SimplicityHL, as a frontend, abstracts away much of the complexity, allowing users to write smart contracts, with minimal code and high reliability. SimplicityHL keeps the computer science fundamentals close enough that you can reason about it formally when needed.

- Andrew Poelstra

Try Simplicity Now

Adapt our extensive library of existing contracts to your needs, or start writing your own. Available on Liquid with multi-asset support and Bitcoin’s Mutinynet.

Simplicity on Liquid and Bitcoin