Tech Stack

Cairo is a programming language for writing programs whose execution can be proved with STARKs. It is also the smart-contract language of Starknet.

The Cairo compiler translates programs into instructions for the Cairo virtual machine. Developers can write application logic without designing the mathematical constraints required for a STARK proof.

StarkWare develops the Cairo language and its Rust-based toolchain, including tools for compiling, testing and debugging programs.

Build demanding applications on a permissionless network with capacity for more than 1,000 transactions per second.

STARK proofs verify entire blocks of transactions together. Verification costs grow far more slowly than the computation they cover, bringing high throughput and low fees to applications.

Developers build in Cairo, with native account abstraction for flexible signing and account recovery. Starknet’s Cairo-based operating system makes the execution of these transactions provable.

Stwo generates proofs through SHARP, which combines them for verification on Ethereum. Starknet operates as an Ethereum Layer 2: its state updates are accepted only after the proofs pass verification.

StarkEx is an application-specific scaling engine built on STARK proofs. Applications submit transactions through its API for batching and proving, with state updates verified on Ethereum.

The off-chain services are implemented in Python and typically implement a cloud micro-services architecture.

Stone generates STARK proofs of Cairo program execution, producing compact proofs that are efficient to verify.

By August 2023, scaling systems built on Stone, including StarkEx and Starknet, had proved 500 million transactions, $1 trillion in cumulative transaction volume and more than 100 million NFT mints.

Stone is open source under the Apache 2.0 license. SHARP also uses Stone at the final stage of proof aggregation.

SHARP (SHARed Prover) combines proofs from many Cairo programs into a single proof for Ethereum. Applications share one verification cost, making large-scale computation more economical.

It is StarkWare’s proving and aggregation service for Starknet. SHARP uses Stwo to generate proofs and recursive proving to combine them, with Stone producing the final proof for Ethereum’s verifier.

Stwo brings fast proof generation to Starknet’s scaling and STRK20’s privacy. StarkWare’s open-source prover and verifier is built on Circle STARKs, using efficient 32-bit arithmetic on CPUs. It is written in Rust under the Apache 2.0 licence.

Developers can use Stwo to prove Cairo program execution or build their own proving systems. The same core technology runs in SHARP, where it proves computation for Starknet in production.