Smart contracts you can prove.

Simplicity is a low-level, typed, functional language for Bitcoin smart contracts, designed so you can verify exactly what a program does before it runs. A Blockstream Research project, live on the Liquid Network.

Most smart-contract bugs come from not knowing what the code will do. Simplicity is designed so you can prove a contract's behavior before a single satoshi moves.

How it works

Programs you can reason about, line by line.

A Simplicity program is built from a small set of combinators that compose into the full logic. Because the language is so constrained, a tool can analyze a program and tell you exactly what it accepts, with mathematical certainty.

The expression below is illustrative, not a screenshot.

◆ Illustrative
// a spending condition, proven before it runs
assert verify_sig(pubkey, sig)
and check_locktime(height)
comp witness script
// type-checked, cost-bounded, fully analyzable
The model

From a small core to a proof of behavior.

Combinators

A handful of primitives compose into any program.

Bit Machine

A model that measures exactly what a program costs to run.

Proof

Reason about what the contract will do before it runs.

Why Simplicity

Built so the hard questions have answers.

Formal verification

Reason about a program with mathematical certainty, not testing alone.

A small core

A handful of combinators compose into any program, which keeps each one easy to analyze.

The Bit Machine

A model for measuring exactly how much computation a program costs.

Built for Bitcoin

Designed for Bitcoin and live today on the Liquid Network.

A language with a precise definition.

Paradigm
Low-level, typed, functional
Built from
A small set of combinators
Verification
Designed for formal proof of behavior
Cost model
The Bit Machine measures resource use
Network
Live on the Liquid Network
Higher-level
Simfony compiles down to Simplicity
Origin
A Blockstream Research project
Write it in Simfony

A higher-level language that compiles to Simplicity.

Simfony is a Rust-like language that compiles down to Simplicity, so you can write contracts in a familiar style and still get the verifiability of the layer beneath.

Explore Simfony and Simplicity

Build contracts you can verify.

Simplicity is open research, available today on the Liquid Network. Read the language docs, browse the source, or see where it runs.