StarkWare unveils new ZKThreads framework in its ‘fractal scaling’ arsenal

Layer 2 developer StarkWare, along with Cartridge, has introduced a new scaling framework called ZKThreads to improve the scalability of decentralized applications on Layer 2 Starknet through execution sharding enabled with zero knowledge proofs.

This builds on the fractal scaling vision that StarkWare introduced in 2021.

ZKThreads will be used to broaden Starknet’s array of “fractal-scaling” solutions, offering an alternative to the existing ZK coprocessors that function in a similar manner, StarkWare told The Block.

As such, existing coprocessors, despite being effective, often operate independently, which leads to fragmented liquidity and reduced interoperability among applications. The introduction of ZKThreads aims to address these fragmentation issues by providing a standardized development environment that supports provable applications.

The execution sharding as applied by ZKThreads will efficiently handle different segments of network transactions or computations while maintaining security through zero-knowledge proofs. This setup ensures that blockchain dapps can scale effectively by distributing the computational and transactional load, without compromising the decentralization or security of the network.

The framework will also be available alongside Layer 3 chains in the Starknet ecosystem. Such Layer 3 chains support the scaling of dapps that require fully customizable control, whereas ZKThreads is designed for more flexible scaling — ensuring liveness at every step by allowing for direct fallback onto the base layer. The objective will be greater composability, security, and interoperability for ecosystem dapps.

“ZKThreads open the door to executing directly on Starknet when needed, ensuring liveness at every step and leaner design for dapps,” Louis Guthmann, head of product strategy at StarkWare, told The Block.

Starknet-based developer Cartridge will initially utilize ZKThreads to scale on-chain games. The estimated development timeline for the launch of ZKThreads is expected to be nine months before which it will be implemented on the testnet.

How does it work?

At the core of ZKThreads’ architecture are several essential components: a batcher, a prover, and various contracts that handle application logic and state changes on a network such as Starknet. This setup aims to guarantee that transactions are both accurate and usable across Starknet.

Another aspect of ZKThreads is its ability to facilitate direct executions on Starknet when required. This is accomplished by implementing application logic in the thread’s app contracts, which oversee the creation and modification of transactions and state changes. These transactions are then grouped into sub-blocks, enhancing processing times and optimizing resource utilization.

ZKThreads is expected to scale high-performance dapps on Starknet, particularly for session-based on-chain games like poker and chess. Players will only need to pay fees once the game concludes and the results are recorded on the public Starknet, making it economically viable to host a broader range of game genres entirely on the blockchain, StarkWare stated.

This framework is also set to enhance decentralized applications, particularly decentralized exchanges on Starknet. For example, decentralized exchanges could experience a significant reduction in operational costs, as ZKThreads will enable users to incur fees only at the point of cashing out, rather than on every trade.