Kaspa Roadmap: 2026 and Beyond

Crescendo: 1 Block Per Second

The Crescendo upgrade brought Kaspa from 1 block per 10 seconds to 1 block per second. This was the first major throughput milestone and demonstrated that GHOSTDAG consensus could handle significantly higher block rates than traditional blockchains.

Toccata: Native Programmability

The Toccata hard fork activated between June 5 — 20, 2026. It introduced three pillars of L1 programmability:

• Native Assets (KIP-9): L1 token creation with mint, burn, and transfer capabilities, fully integrated into Kaspa's UTXO model
• Silverscript (KIP-15): A lightweight, UTXO-native covenant system that enables programmable spending conditions directly on L1 without a separate VM. Silverscript supports covenant-based vaults, time-locked conditions, multi-sig logic, and auction mechanics
• ZK Verification Opcodes (KIP-20): Native Groth16 proof verification opcodes baked into the consensus layer, allowing any transaction to verify a zero-knowledge proof on-chain without external oracles or bridges
• Partitioned Sequencing Commitment (KIP-21): An efficient commitment scheme that partitions transaction sequencing data into multiple parallel segments, reducing proof generation overhead and enabling scalable ZK-rollup-style settlement on Kaspa L1

See our Toccata Hard Fork Guide for full details.

DAGKnight: Adaptive Consensus

DAGKnight is the next major consensus upgrade. The DAGKnight development branch has been active in the main rusty-kaspa repository since February 27, 2026, with ongoing commits and iterative improvements. It introduces adaptive consensus rules that improve network resilience during partial splits and adversarial conditions. Key has:

• Net-split safety: the network can recover cleanly from partitioning events
• Precise block orderingeterministic ordering across the DAG even under adversarial network conditions
• Instant finality: transactions become irreversible nearly instantly, eliminating reorg risk for applications
• Improved orphan resistance during high-throughput periods
• Foundation for 10 BPS and 100 BPS operation

Precise block ordering and instant finality are essential prerequisites for vProgs, as smart contracts require deterministic execution ordering and guaranteed settlement finality.

10 → 100 Blocks Per Second

Building on DAGKnight's improved consensus, Kaspa will scale from the current 1 BPS to 10 BPS and eventually 100 BPS. At 100 BPS, Kaspa would be capable of processing thousands of transactions per second: competitive with Visa and Mastercard's average throughput. Block propagation optimization, DAGKnight's adaptive consensus, and network-level improvements are all prerequisites for this milestone.

vProgs: Native L1 ZK-Verified Smart Contracts

vProgs (verifiable programs) are Kaspa's native L1 smart contract system: they live on Layer 1, not on a separate chain, rollup, or sidechain. A proof-of-concept demo was successfully conducted on February 19, 2026 by Maxim Biryukov, demonstrating a complete deposit-transfer-withdraw cycle for a ZK covenant rollup.

Architecture

• Native to L1: vProgs execute as excellent primitives within Kaspa's consensus layer, not on a separate execution layer or L2
• Off-chain execution + on-chain ZK verificationrogram execution happens off-chain; only a succinct zero-knowledge proof is submitted to L1 for verification via Toccata's native ZK opcodes
• Account model: unlike Kaspa's base-layer UTXO model, vProgs use an account-based state model, enabling familiar smart contract patterns and composable interactions
• Sovereign per-vProg state: each vProg maintains its own independent state and gas accounting, preventing one program's activity from congesting another
• Atomic composability: vProgs can atomically compose with each other via concise witnesses (Merkle inclusion proofs), enabling trustless cross-program calls without a shared global state
• L1 sequencing: transaction ordering is handled by Kaspa's own DAG-based consensus, eliminating the need for a separate sequencer or trusted third party
• Language-agnostic execution layerevelopers can write vProgs in any language that compiles to a supported proving backend:
  • Noir: native ZK language for inline zero-knowledge circuits (fastest proof generation, ideal for simple covenants and verifiable computations)
  • RISC Zero / SP1: zkVM environments for standard Rust applications (general-purpose smart contracts with full Rust ecosystem support)
  • Cairo: STARK-based VM for rollup-style applications requiring high-throughput batched execution
• STORM constants: throughput, state size, and resource usage are regulated by configurable STORM (State, Throughput, Operations, Resources, Memory) constants, ensuring predictable performance and preventing resource exhaustion

Proof Times

• Noir / Groth16: ~1 second proof generation, suitable for latency-sensitive applications like DEX swaps and payments
• RISC Zero / SP1: 10 — 30 second proof generation, appropriate for general-purpose smart contracts where computational complexity is higher

Development Tiers

1. Inline ZK: Simple ZK circuit verification embedded directly in transactions. Best for atomic swaps, private transfers, and covenant logic.
2. Based ZK Apps: Full general-purpose applications using RISC Zero/SP1 zkVMs with per-application sovereign state and atomic composability.
3. Based ZK Rollups: High-throughput batched execution using Cairo or custom STARK provers, settling aggregated proofs on Kaspa L1.