Smart-Contract DSLs Family Index
type: language-family-index family: smart-contract languages_catalogued: 26 tags: [language-reference, family-index, blockchain, smart-contract, web3, defi, formal-verification]
Smart-Contract DSLs — Family Index
- Type: Family index (Tier 3)
- Family: Smart-contract DSLs (on-chain languages)
- Languages catalogued: 26
- Last updated: 2026-05-07
Family overview
Smart-contract DSLs are a constrained-execution class of language. Unlike general-purpose languages, they run inside a deterministic VM, are gas-metered (every operation has a measurable cost paid in chain currency), are sandboxed from the host OS and external I/O, and many are deliberately not Turing-complete so that termination, cost, and behaviour can be statically bounded. The audience is small (a few thousand serious authors per chain) but the economic blast radius is enormous — a single Solidity bug has cost users hundreds of millions of dollars on more than one occasion, which is why this family is unusually obsessed with formal verification, type discipline, and language-level safety.
The defining feature of the field in 2026 is chain-by-chain divergence. Each major L1 ended up with its own language family rather than converging on a shared standard: Ethereum has Solidity/Vyper/Yul/Huff, Aptos and Sui share Move, Starknet has Cairo, Stacks has Clarity, Cardano has Plutus/Aiken/Marlowe, Tezos has LIGO/SmartPy/Michelson, TON has FunC/Tact/Tolk, Cosmos chains use CosmWasm-Rust, Polkadot has Ink!/ask!, Kadena has Pact, Fuel has Sway, Zilliqa has Scilla. There has been almost no language-level interoperability — a Solidity dev is not a Move dev. A recurring tension runs through the whole family: Solidity dominates by network effect (TVL, tooling, audit firms, dev mindshare) while almost every newer language was designed to be safer-by-construction (Vyper’s restricted feature set, Move’s resource-typed assets that can’t be copied, Aiken’s pure-functional UTXO model, Clarity’s decidability).
The verification angle is the family’s intellectual centrepiece. Move ships with the Move Prover (SMT-based, derives from Boogie/Z3 lineage); Clarity is decidable by design (no recursion, no unbounded loops — every contract’s behaviour is statically analysable); Plutus runs on Haskell so Cardano contracts inherit GHC’s type system and a mature property-testing ecosystem; the K-EVM project gives Solidity a formal semantics retroactively. Above this sits the ZK-circuit tier — Cairo (Starknet), Noir (Aztec), Halo2 / Plonky2 / Circom — where the language compiles not to a VM but to an arithmetic circuit suitable for zero-knowledge proving. This is genuinely a separate sub-paradigm and is reshaping what “smart-contract DSL” means going into the late 2020s.
In our deep library
None of these languages have full deep notes — they’re niche-by-chain and the deep library prioritises broadly-used general-purpose languages. Cross-references:
- experimental-and-cross-host — previously held a handful of smart-contract entries (Solidity, Move, Cairo, Sway, Motoko); those are now duplicated and centralised here.
- rust — direct ancestor/influence for Ink!, Sway, and CosmWasm; Move’s syntax is also Rust-flavoured.
- haskell — Plutus is literally embedded Haskell; PlutusTx is a GHC plugin; Marlowe was prototyped in Haskell.
- python — Vyper and SmartPy take direct syntactic inspiration from Python.
- notation-spec — Move Prover specification language and DAML’s verification angle live in the spec/verification family.
- logic-and-constraint — SMT solvers (Z3, CVC5) underpin every prover in this family.
Tier 3 family table
| Language | First appeared | Chain(s) | Paradigm | Status (2026) | URL |
|---|---|---|---|---|---|
| Solidity | 2015 | Ethereum + EVM L2s (Arbitrum, Optimism, Base, Polygon, BNB Chain, etc.) | Imperative, contract-oriented; C++/JS-flavoured | Dominant; v0.8.x active; ~80%+ of all on-chain TVL | https://soliditylang.org/ |
| Vyper | 2017 | Ethereum + EVM | Pythonic, deliberately restricted (no inheritance, no inline assembly by default) | Active; Curve-Finance-class projects use it; ongoing v0.4 work | https://docs.vyperlang.org/ |
| Yul | 2017 | Ethereum (Solidity IR) | Low-level intermediate; SSA-ish | Stable as Solidity’s IR; Yul+ extensions niche | https://docs.soliditylang.org/en/latest/yul.html |
| Huff | 2019 | Ethereum | Hand-rolled EVM assembly with macros | Niche; used for ultra-gas-optimised libs (e.g. Huffmate) | https://huff.sh/ |
| Move | 2019 | Aptos, Sui (originally Diem/Libra) | Resource-oriented; linear types; Rust-flavoured | Active and the clear #2 platform after EVM; Aptos and Sui have diverged dialects | https://move-language.github.io/move/ |
| Cairo | 2020 (Cairo 1 in 2023) | Starknet (also generic STARK proving) | Rust-flavoured, ZK-targeted; provable execution | Active; Cairo 1.x is the modern surface, Cairo 0 deprecated | https://www.cairo-lang.org/ |
| Clarity | 2020 | Stacks (Bitcoin L2) | LISP-flavoured, decidable, no Turing-completeness | Active; Stacks Nakamoto upgrade (2024) revitalised the chain | https://docs.stacks.co/clarity |
| Ink! | 2019 | Polkadot/Substrate parachains, Astar, Aleph Zero | Rust eDSL; compiles to Wasm contracts | Active; ink! v5 stable, 6.x in development | https://use.ink/ |
| ask! | 2021 | Polkadot/Substrate | AssemblyScript-based contract DSL | Largely dormant; Ink! won the Polkadot mindshare race | https://ask-lang.github.io/ |
| Plutus | 2020 | Cardano | Haskell-based; Untyped Plutus Core (UPLC) is the on-chain ISA | Active; Plutus V3 live (Chang upgrade, 2024) | https://plutus.cardano.intersectmbo.org/ |
| PlutusTx | 2020 | Cardano | GHC plugin compiling Haskell subset → UPLC | Active; the actual on-chain compilation path for Plutus contracts | https://plutus.readthedocs.io/ |
| Aiken | 2022 | Cardano | Pure-functional, Rust-flavoured, UTXO-native | Active and the modern alternative most new Cardano dApps choose; v1.x stable | https://aiken-lang.org/ |
| Marlowe | 2018 (mainnet 2022) | Cardano | DSL for financial contracts; bounded by construction | Active but niche; positioned for regulated finance use cases | https://marlowe.iohk.io/ |
| Pact | 2017 | Kadena | LISP-flavoured; module/key-row schema; built-in formal verification | Active; Pact 5 (2024) added Rust-based interpreter and ZK primitives | https://docs.kadena.io/pact |
| Sway | 2021 | Fuel Network | Rust-flavoured; UTXO-style on the FuelVM | Active; Fuel mainnet launched 2024; Sway v0.x still pre-1.0 | https://fuellabs.github.io/sway/ |
| FunC | 2020 | TON (The Open Network / Telegram) | C-like, low-level, stack-aware | Active but increasingly framed as the assembly tier under Tact/Tolk | https://docs.ton.org/develop/func/overview |
| Tact | 2023 | TON | High-level OO/actor; TypeScript-flavoured; compiles to FunC | Active and the recommended path for new TON contracts | https://tact-lang.org/ |
| Tolk | 2024 | TON | Successor language, Go/Rust-flavoured, gas-efficient | Early / experimental; positioned as the long-term replacement for FunC | https://docs.ton.org/develop/tolk |
| LIGO | 2019 | Tezos | Multi-syntax (PascaLIGO deprecated, CameLIGO, JsLIGO) | Active; CameLIGO and JsLIGO are the supported syntaxes in 2026 | https://ligolang.org/ |
| SmartPy | 2019 | Tezos | Python-embedded contract DSL | Active; v0.18+; one of the two main Tezos paths | https://smartpy.io/ |
| Michelson | 2018 | Tezos | Stack-based, low-level, formally specified | Stable; the actual on-chain bytecode every Tezos compiler targets | https://tezos.gitlab.io/active/michelson.html |
| ReachLang | 2019 | Cross-chain (Algorand, Ethereum, Conflux, historically others) | High-level participant/consensus model; compiles to multiple targets | Reach Inc. wound down commercial ops in 2024; project largely dormant | https://reach.sh/ |
| DAML | 2016 | Canton (Digital Asset’s privacy-preserving network); also EVM, Hyperledger | Multi-party workflow DSL; functional; rights/obligations modelled directly | Active commercial use in regulated finance; Canton mainnet expanding | https://daml.com/ |
| Scilla | 2018 | Zilliqa | Principled functional, separation of computation and communication | Active but small ecosystem; Zilliqa 2.0 EVM-compat shifted some focus | https://scilla-lang.org/ |
| Hyperledger Fabric chaincode | 2017 | Hyperledger Fabric | General-purpose host langs (Go primary, Node.js, Java) | Active in enterprise/permissioned chains; Fabric 3.x | https://hyperledger-fabric.readthedocs.io/ |
| CosmWasm (Rust) | 2020 | Cosmos chains (Osmosis, Neutron, Juno, Sei, etc.) | Rust eDSL; compiles to Wasm; actor-style messages | Active and the standard contract layer for the Cosmos ecosystem | https://cosmwasm.com/ |
Notable threads
Post-reentrancy era language design. Solidity inherited C++/JavaScript ergonomics and, with them, a class of bugs (reentrancy, integer overflow, delegatecall confusion, storage-collision) that turned into nine-figure exploits — the DAO (2016), Parity multisig freeze (2017), countless DeFi rugs since. Almost every smart-contract language designed after 2017 is a reaction. Vyper drops inheritance, function overloading, and inline assembly to make audits tractable. Move makes assets resources with linear types — they cannot be implicitly copied or destroyed, which categorically eliminates a whole class of double-spend bugs. Sway adopts Rust’s borrow checker for the same reason. Aiken on Cardano is pure-functional UTXO-native, sidestepping shared-state reentrancy entirely. The pattern: each new chain treated Solidity’s footguns as a design lesson.
Formal verification as a first-class concern. This family has more verification tooling per capita than any other. The Move Prover (Microsoft Research lineage, Boogie + Z3) is shipped with the language and used in production at Aptos and Sui. Clarity is decidable — every contract’s runtime behaviour can be statically analysed, achieved by banning recursion and unbounded loops; this is rare in any production language. K-EVM gives the EVM (and by extension Solidity) a complete formal semantics that audit firms like Runtime Verification use. Plutus rides on GHC, inheriting Haskell’s type system and QuickCheck-style property testing. Pact has built-in property checking. Scilla was designed at NUS specifically to be amenable to mechanized verification. The intuition is simple: when the cost of a bug is denominated in millions of dollars and the contract is immutable once deployed, paying for proofs becomes economically rational.
The ZK-DSL tier. A separate sub-paradigm has emerged where the language compiles not to a stack-VM but to an arithmetic circuit suitable for zero-knowledge proving. Cairo (Starknet) is the most mature — it has a custom CPU AIR and a Rust-flavoured high-level language (Cairo 1.x, 2023+). Noir (Aztec, 2022) provides a Rust-like surface that compiles via ACIR to multiple proving backends (Halo2, Plonk, Barretenberg). Circom (2018) and the Halo2 / Plonky2 ecosystems provide lower-level circuit-construction toolkits. As ZK-rollups eat more of the L2 stack, ZK-DSLs are becoming load-bearing for both privacy applications and provable execution at scale. This entire tier didn’t meaningfully exist in 2020 and is now arguably the most active area of language design in Web3.
The TON three-language drama. The Open Network (Telegram’s chain, relaunched 2021) is the clearest case study of a chain churning through languages mid-flight. FunC (2020) was the original — a C-like, stack-aware language that compiled to TVM bytecode and was widely complained about as awkward. Tact (2023) arrived as a higher-level OO-flavoured alternative with a TypeScript-influenced surface, became the recommended path for new contracts within a year, and now ships most production TON dApps. Tolk (2024) appeared as a third official direction — gas-efficient, Go/Rust-flavoured — positioned as the long-term replacement for FunC. Going from one to three contract languages in two years is unusual and reflects both rapid TON growth (driven by Telegram integration) and unsettled language-design opinion in the ecosystem.
Tezos’s three-syntax LIGO experiment. Tezos compiles every contract down to Michelson, a stack-based bytecode with a formal semantics. Above Michelson, the ecosystem deliberately shipped one tool — LIGO — that exposed three different syntaxes (PascaLIGO, CameLIGO, JsLIGO) so devs from different language backgrounds could pick a comfortable surface. PascaLIGO was deprecated in 2023; the surviving CameLIGO (OCaml-flavoured) and JsLIGO (TypeScript-flavoured) cover the two natural-feeling targets. The parallel SmartPy effort gives Python devs a fourth on-ramp. The experiment worked partially — Tezos has more language diversity per capita than any other chain — but never solved the underlying problem that the Tezos ecosystem is small relative to the language tooling investment.
Why Solidity continues to dominate despite the alternatives. Vyper is safer. Move has linear types. Aiken is mathematically prettier. None of them have Solidity’s network effects: every major audit firm (Trail of Bits, Consensys Diligence, OpenZeppelin, Spearbit, Halborn) has Solidity expertise as table stakes; OpenZeppelin’s audited contract libraries are Solidity-only; Foundry, Hardhat, and Tenderly tooling is Solidity-first; every wallet UI knows how to render Solidity ABIs; every L2 ships EVM-compatible because that’s where the developers and users are. Liquidity, tooling, and audit availability compound, and Solidity has had a 5-10 year head start in all three. The realistic outcome for the next five years is not Solidity being replaced but Solidity-the-source-language becoming a thin layer that compiles, increasingly often via Yul, into EVM bytecode that runs on a heterogeneous set of L2s — including ZK-rollups whose underlying proving system is written in Cairo or Noir but whose contracts users write in Solidity.
Citations
- Solidity: https://soliditylang.org/
- Vyper: https://docs.vyperlang.org/
- Yul: https://docs.soliditylang.org/en/latest/yul.html
- Huff: https://huff.sh/
- Move (Aptos): https://aptos.dev/en/build/smart-contracts
- Move (Sui): https://docs.sui.io/concepts/sui-move-concepts
- Move Prover paper (Zhong et al., 2020): https://research.facebook.com/publications/the-move-prover/
- Cairo: https://www.cairo-lang.org/
- Starknet docs: https://docs.starknet.io/
- Clarity: https://docs.stacks.co/clarity
- Stacks Nakamoto upgrade: https://stacks.org/nakamoto
- Ink!: https://use.ink/
- ask!: https://ask-lang.github.io/
- Plutus: https://plutus.cardano.intersectmbo.org/
- Aiken: https://aiken-lang.org/
- Marlowe: https://marlowe.iohk.io/
- Pact: https://docs.kadena.io/pact
- Sway: https://fuellabs.github.io/sway/
- FunC: https://docs.ton.org/develop/func/overview
- Tact: https://tact-lang.org/
- Tolk: https://docs.ton.org/develop/tolk
- LIGO: https://ligolang.org/
- SmartPy: https://smartpy.io/
- Michelson: https://tezos.gitlab.io/active/michelson.html
- Reach: https://reach.sh/
- DAML: https://daml.com/
- Scilla: https://scilla-lang.org/
- Hyperledger Fabric chaincode: https://hyperledger-fabric.readthedocs.io/en/latest/smartcontract/smartcontract.html
- CosmWasm: https://cosmwasm.com/
- Noir (Aztec): https://noir-lang.org/
- K-EVM (Runtime Verification): https://github.com/runtimeverification/evm-semantics