Yes, Kaspa has smart contracts — in two layers. Since the Toccata hard fork on June 30, 2026, Kaspa's layer 1 runs native covenant contracts: programmable spending rules that live directly inside UTXOs, written in the high-level language Argent. And on top of layer 1, two EVM layer 2s — Kasplex and Igra — run full Ethereum-style contracts, with the live capital committed to them shown below.
Kaspa's answer to smart contracts is unusual because it refuses the standard shortcut. Most chains bolt a single global virtual machine onto their base layer. Kaspa instead built three distinct levels, each with its own job:
Kaspa's base layer is a UTXO chain, like Bitcoin. A covenant is a programmable spending rule attached to a UTXO: the coin itself carries code plus a piece of state, committed on chain as a hash. Whoever wants to spend that coin must reveal the code and state, and the network verifies that the spend follows the rules. There is no global computer executing everyone's programs — each contract is a small, self-contained state machine partitioned across UTXOs, which is why covenant apps inherit layer 1's speed and parallelism instead of competing for one shared engine.
Raw covenant scripting is unforgiving — one wrong byte and funds are stuck. Argent is the high-level language built to fix that: developers define actors (a contract plus the state it owns), entries (the operations you can call), and transition rules, and the compiler generates the underlying script. Two design choices matter for non-developers too. Every app is a closed system under one covenant ID — outside code cannot inject itself into an app's state machine. And the compiler is only needed at build time; creating transactions afterwards needs only a lightweight runtime, so tooling in other languages can drive the same apps. Core developer Michael Sutton documents the whole workflow in public live-coding sessions on the Kaspa Native channel — episode one builds a working ticketing app from scratch.
For everything that expects Ethereum — Solidity contracts, MetaMask, existing DeFi codebases — Kaspa has two EVM layer 2s that settle against layer 1: Kasplex, a zkEVM live since 2025, and Igra, live since 2026. This is where Kaspa's DeFi actually operates today, and where the TVL shown above lives. The trade-off is the standard one: EVM compatibility and rich tooling, in exchange for each L2's own performance and trust profile.
The comparison everyone wants, done honestly:
| Ethereum | Kaspa L1 covenants | Kaspa L2s | |
|---|---|---|---|
| Model | one global virtual machine | state machines inside UTXOs | EVM, per rollup |
| Where state lives | global account tree | partitioned across UTXOs | the L2's own state |
| Language | Solidity and friends | Argent | Solidity and friends |
| Runs existing ETH code | natively | no — different model | yes |
| Maturity | since 2015 | since june 2026 | since 2025–2026 |
Neither approach is free. Ethereum's global machine makes composability trivial and congestion structural. Kaspa's partitioned model keeps the base layer fast and parallel, but asks developers to learn a genuinely different way of building — which is why the tooling work around Argent matters as much as the protocol itself.
Years of "Kaspa is payments only, no smart contracts" left a deep imprint — you will still hear it from commentators and see it in older articles. It stopped being true on June 30, 2026. Anyone repeating it today is describing a chain that no longer exists; check the activation date, not the vibes.
The layer 2s are their own systems. They inherit settlement from Kaspa's layer 1, but their throughput, latency and trust assumptions are their own. When you see EVM performance claims, ask which layer they describe — the honest answer is almost never "layer 1."
The first wave of covenant apps and L2 protocols is weeks-to-months old. Some launched anonymous, some unaudited, and the standard advice from Kaspa's own core contributors is blunt: know what you buy. A working demo is not a security review. The mechanism being sound says nothing about any individual app being safe.