Updated July 2026 Kaspa Roadmap: 2026 and Beyond
Kaspa's development roadmap is organized around four major phases: throughput scaling (Crescendo), programmability (Toccata), adaptive consensus (DAGKnight), and native ZK-verified smart contracts (vProgs). Here's where the project stands and what's coming next.
Current Phase: Toccata activated June 30, 2026. DAGKnight development targeting Q3 2026 with 25-40 BPS throughput. vProgs progressing toward standalone Phase 1 deployments.
Completed Milestones
Phase 1Completed May 2025 Crescendo: 10 Blocks Per Second
The Crescendo upgrade brought Kaspa from 1 block per second to 10 blocks per second. This was the first major throughput milestone and demonstrated that GHOSTDAG consensus could handle significantly higher block rates than traditional blockchains.
Phase 2Completed June 2026 Toccata: Native Programmability
The Toccata hard fork activated on June 30, 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.
Post-Toccata Ecosystem
The activation of Toccata has already catalyzed significant ecosystem growth on Kaspa. Key developments include:
- Kaspagent AI Agent Marketplace Launched: A decentralized marketplace for AI agents built on Kaspa L1, leveraging Silverscript covenants and Native Assets for agent creation, discovery, and payment settlement
- KRC-20 Tokens Minting Live: Community-driven token creation and minting is now operational using Kaspa's L1 Native Assets infrastructure, with multiple projects already deploying tokens
- 2.35 Billion Transactions Milestone: Kaspa's network has surpassed 2.35 billion total transactions, demonstrating sustained usage and the scalability of the GHOSTDAG consensus mechanism at 10 BPS
Current & Upcoming Milestones
Phase 3 — 2026-2027Active Development
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. DAGKnight is now targeting 25-40 BPS throughput by Q3 2026, with the full 100 BPS target on the roadmap for 2027. Key features:
- Net-split safety: the network can recover cleanly from partitioning events
- Precise block ordering: deterministic 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
- 25-40 BPS target for Q3 2026, scaling to 100 BPS by 2027
Precise block ordering and instant finality are essential prerequisites for vProgs, as smart contracts require deterministic execution ordering and guaranteed settlement finality.
Throughput — 2027Planned
10 → 100 Blocks Per Second
Building on DAGKnight's improved consensus, Kaspa will scale from the current 10 BPS to 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.
Smart Contracts — 2026 H2 → 2027Post-PoC Development
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 verification: Program 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 layer: Developers 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
- Inline ZK: Simple ZK circuit verification embedded directly in transactions. Best for atomic swaps, private transfers, and covenant logic.
- Based ZK Apps: Full general-purpose applications using RISC Zero/SP1 zkVMs with per-application sovereign state and atomic composability.
- Based ZK Rollups: High-throughput batched execution using Cairo or custom STARK provers, settling aggregated proofs on Kaspa L1.
What vProgs Enable
The combination of native ZK verification, account-model state, atomic composability, and L1 sequencing opens the door to a wide range of decentralized applications on Kaspa:
- Decentralized Exchanges (DEX): Trustless token swaps with atomic execution and instant finality. vProgs enable order-book or AMM-style exchanges where each trade is verified via a succinct ZK proof.
- Lending & Borrowing: Overcollateralized lending markets with automatic liquidation via covenant-enforced conditions. Sovereign per-vProg state ensures lending protocols don't compete for block space.
- Stablecoins: Overcollateralized (DAI-style) or algorithmic stablecoins with on-chain ZK proofs of solvency. See the Kaspa Stablecoin Timeline for the projected launch roadmap.
- DAOs: Fully on-chain decentralized autonomous organizations with ZK-verified voting, treasury management, and proposal execution.
- Gaming: On-chain game logic with off-chain execution and ZK proof submission, enabling high-frequency game actions with L1 settlement.
- Enterprise: Private computation on shared L1 infrastructure using ZK proofs for confidentiality, with auditability through Kaspa's public DAG.
Kaspa Stablecoin Timeline
Stablecoins are one of the most anticipated use cases enabled by Toccata's native assets and vProgs' ZK programmability. With L1 native asset creation (KIP-9) already live, and vProgs Phase 1 targeting standalone operation in 2026 H2, the foundation for overcollateralized and algorithmic stablecoins on Kaspa is being laid now. See the dedicated Kaspa Stablecoin Timeline guide for projected phases, collateral types, and integration milestones.
Layer 2: Kasplex
Parallel to the L1 roadmap, Kasplex is building a zkEVM Layer 2 on top of Kaspa. Kasplex settles ZK proofs on Kaspa L1 (using Toccata's native ZK infrastructure) and provides EVM compatibility for Ethereum dApps. See our Kasplex L2 Guide for details.
Roadmap Timeline Overview
| Period |
Milestone |
Status |
Impact |
| 2025 |
Crescendo (10 BPS) |
Done |
10x throughput increase |
| 2026 Q2 |
Toccata Hard Fork |
Done |
Programmability: assets, covenants, ZK opcodes, KIP-21 commitment scheme |
| 2026 H2 |
Standalone vProgs (Phase 1) |
🔄 In development |
First standalone vProg applications with sovereign state and ZK proof verification on L1 |
| 2026 Q3 — 2027 |
DAGKnight — 25-40 BPS → 100 BPS |
🔄 Active development, 25-40 BPS targeting Q3 2026 |
Adaptive consensus, precise block ordering, instant finality, 25-100 BPS throughput |
| 2027 |
Full composable vProgs |
🔮 Planned |
Atomic composability between vProgs, multi-language proving (Noir, RISC Zero, SP1, Cairo), production-grade STORM constants |
| 2027 |
10 → 100 BPS |
🔮 Planned |
Massive throughput scaling, thousands of TPS |
vProgs PoC Demo: On February 19, 2026, Kaspa core developer Maxim Biryukov demonstrated a working vProgs proof-of-concept, executing a complete deposit-transfer-withdraw cycle for a ZK covenant rollup. This validated the core architecture of off-chain execution with on-chain ZK verification on Kaspa L1.
What This Means for Kaspa Users
- 2026 Q2: Token creation, covenants, and ZK applications become possible. Developers can start building on Kaspa L1 with Native Assets and Silverscript.
- 2026 H2: First standalone vProgs go live. Simple ZK applications with sovereign state become operational on mainnet.
- Late 2026: DAGKnight brings 25-40 BPS throughput, instant finality, and prepares the network for 100 BPS scaling and composable smart contracts.
- 2027: Full composable vProgs with atomic cross-program calls, multi-language proving, and production-grade STORM constants. Kaspa becomes one of the fastest and most versatile PoW networks ever built.
Important: Roadmap timelines are estimates and subject to change. Kaspa is developed by a distributed team of contributors — there is no central company making promises. Development pace depends on contributor availability, funding, and technical challenges encountered.
Last updated: July 2026. Roadmap milestones and dates are subject to change. Follow Kaspa's official communication channels for the most current development updates.
← Back to Kaspa Guide Home