High-assurance bitcoin smart contracts.
Simplicity is a UTXO-based smart contracting language for bitcoin, designed for verifiable security, financial correctness, and high-value applications.
Know what your contracts do before they run.
A Simplicity contract is a spending condition on coins: it doesn't call other contracts, touch shared state, or loop without bound. That narrower model makes contracts easier to analyze. Their resource use is known ahead of time, and the language has a formal, machine-checked specification.
Execution costs bounded before you broadcast.- No external calls, so a smaller attack surface.
- A formally specified and verified core language, Rocq.
- Only the executed branch is revealed on-chain.
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. Financial applications inherit a small, precisely defined base: bounded costs, no shared state, and no ambiguity in what the consensus layer will do. Developers write SimplicityHL, full nodes execute Simplicity.
Familiar to read.
SimplicityHL looks like Rust: let, match, typed functions. Underneath, a program is a predicate over a transaction. It either authorizes a spend or it doesn't. There's no heap, no global state and no unbounded loops.
Explicit to reason about.
Everything a contract depends on is in front of you: the transaction it inspects, the witness data it receives, and the conditions it asserts. Nothing else can change that state while it runs.
Compiled to Simplicity.
The SimplicityHL compiler turns your code into Simplicity, the low-level language that full nodes execute. Common operations like hashing and signature checks run as optimized jets.
Coming from the EVM?
The EVM offers more flexibility and composability. Simplicity is deliberately more restrictive, trading some of that flexibility for stronger security guarantees.
| EVM | Simplicity |
|---|---|
State Each contract keeps persistent storage that its functions read and write. | State State lives in the coins (UTXOs) a contract locks and is carried forward in transaction outputs. |
Checks
| Checks
|
Costs Gas is metered at runtime, and a reverted transaction still pays for the gas it used. | Costs CPU and memory use have a static upper bound, known before broadcast. Invalid transactions are never mined. |
Authorization
| Authorization Signatures are checked explicitly, e.g. |
Composition Contracts call each other, and one call can trigger many others. | Composition No contract calls. Several contracts compose by being spent in the same transaction. |
Re-entrancy Guarded against with checks-effects-interactions or | Re-entrancy Not a class of bug. With no external calls, execution can’t be re-entered. |
Tokens ERC-20 and ERC-721 contracts. | Tokens Native Liquid assets, issued at the protocol level. Contracts constrain how they move. |
Built with Simplicity.
Open-source protocols, demos, and research projects on Liquid.
DemoP2P lending
A peer-to-peer lending protocol in pure SimplicityHL. Borrowers post collateral, lenders fund offers, and the covenant enforces repayment or liquidation at expiry.
DemoDecentralized asset management protocol
Regulated assets on Liquid. A Simplicity covenant enforces whitelists, blacklists, and transfer limits with no issuer signature on each transfer, and issuers can produce signed confidential audit reports.
DemoNative multisig
Multisig custody contracts with Rocq proofs that reach from the security model all the way down to the deployed compiled bytes.
ReferenceOptions & offers
Option and option-offer contracts, plus on-chain state management patterns, built with Smplx and tested on a local Liquid regtest.
In developmentPrice oracle
A Simplicity-powered, decentralized price oracle for Liquid. The draft specification is public and development happens in the open.
ResearchPost-quantum signatures
A SHRINCS hash-based signature verifier written in Simplicity, used by the PQ Liquid Wallet to sign transactions on Liquid testnet.
High-assurance financial programming.
Since Simplicity contracts are auditable and provable 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.
A growing ecosystem.
Open-source tools for writing, testing, and shipping SimplicityHL contracts.
Simplicity
The low-level language executed by full nodes, with a formal specification in Coq and reference implementations in C and Haskell.
GitHub
SimplicityHL
The Rust-like high-level language and its compiler, simc, which compiles to Simplicity.
GitHub
SimplicityHL std
The standard library: overflow-checked arithmetic, 128- and 256-bit integers, secp256k1 helpers, and assertions.
GitHub
Smplx
A development framework for SimplicityHL: project CLI, Rust SDK, and a local Liquid regtest for integration tests.
GitHub
rust-simplicity
Rust library for constructing, analyzing, and executing Simplicity programs.
GitHub
VSCode extension
Syntax highlighting, diagnostics, completion, hover, and go-to-definition for .simf files.
Marketplace
SimplicityHL LSP
The language server behind the extension, usable from any LSP-capable editor.
GitHub
Simfmt
A formatter for SimplicityHL code, also available as a library for editor and tool integrations.
GitHub
Web IDE
Write, compile, and run SimplicityHL in the browser, with no local setup.
Open
Try Simplicity now.
Start from the example contracts and the standard library, or write your own. Live on Liquid with native multi-asset support, and available on a bitcoin signet for experimentation.