You can use StarkNet’s block explorer, Voyager

A good place to start is the Hello StarkNet tutorial, which guides the developer step by step through writing and deploying a simple contract. The StarkNet Playground offers an environment for learning how to write StarkNet contracts and test them. 

You can become part of the developers’ community, and support it, by joining the StarkNet Discord server.


SHARP (shared prover) is a service that allows proving the execution of several Cairo programs in the same proof. The Cairo program enforcing the validity of Starknet’s state transition, the StarkNet OS, can make use of SHARP. Namely, proving StarkNet’s state transition can be done together with a bunch of programs that are unrelated to StarkNet, lowering the marginal cost of each participant. Whether or not it is worthwhile for StarkNet to use SHARP or have a dedicated prover depends on several parameters, most prominently the TPS (transactions per second). Large executions might not benefit too much by sharing the proof with much smaller programs.

STARKs are defined as Validity proofs, meaning they prove computational integrity. With Validity proofs (STARKs included), one party can prove to another that a certain computation was done correctly. With Zero-Knowledge proofs, the prover does not have to reveal any information included in the computation, except for the fact that the computation was done correctly.

Most ZK-Rollups are not really Zero-Knowledge. The mistake comes from the confusion between Validity proofs (assures computational integrity) and Zero-Knowledge proofs (assures no information is revealed).

StarkNet uses STARK Validity proofs. It is worth noting that extracting information from the proof is extremely hard – almost impossible in practice.

It is possible to deploy various privacy protocols on StarkNet, which will offer full privacy from all network participants. Since those protocols usually require a lot of computation, they will benefit greatly from StarkNet scalability.

However, it is worth mentioning that by default, Starknet transactions and their payloads are visible to the network in the same way that they are visible on Ethereum.


Cairo is a programming language for scaling dApps using STARKs. It is a Turing complete language, making it possible for all blockchain developers to harness the power of STARKs. More information here.

STARK is a proof system. It uses cutting-edge cryptography to provide polylogarithmic verification resources and proof size, with minimal and post-quantum-secure assumptions. More information here

Cairo is a Turing-complete language that was designed for the purpose of succinctly proving the correct execution of a program (enforcing computational integrity). A Cairo program is stateless, meaning you do not have native access to storage, or to other Cairo programs, nor to the L1 state (although you can access those, as explained below). 

In the Starknet VM, there is a persistent state that smart contracts can access and modify. These smart contracts can store variables, communicate with other contracts, and send/receive messages to/from L1 (read more). StarkNet is an operating system where you can write and deploy smart contracts (written in the Cairo programming language, with some StarkNet-related modification).

No. You have several options for writing a contract; each one has its own benefits. 

Cairo is the native language for a StarkNet contract that fully optimizes the scaling potential of StarkNet.

At the same time, teams are developing transpilers from Solidity and other programming languages to Cairo. These transpilers will allow for quick deployment of existing contracts on StarkNet.

See our latest development tooling.

Operating on StarkNet

StarkNet is evolving to become fully permissionless, allowing anyone to operate on the network:

  1. Sequencers  – Anyone will be able to operate a sequencer, i.e., batch transactions and propose new blocks (somewhat analogous to Ethereum miners, without the Proof of Work part).
  1. ProversAnyone will be able to set up a prover and create proofs for the validity of new blocks.
  1. DevelopersDevelopers will be able to deploy their smart contracts – permissionlessly.
  1. UsersUsers will be able to send transactions permissionlessly. As the system will be decentralized, the possibility of censorship will be eliminated.

Any dApp can be deployed on StarkNet. As Cairo allows general computation, this means that any business logic can be implemented and processed over StarkNet. 

Anyone can interact with StarkNet and deploy contracts. 

During the Alpha phase, developers need to make sure they are aware of the network status as part of the onboarding process. 

For taking the first step in the deployment process, please click here!

The decentralization of the network has two aspects:

  1. The permissionless layer of Sequencers and Provers ensures that the network will be censorship-resistant.
  2. The usage of STARK-proofs ensures that the state is correct, allows everyone to verify the entire StarkNet chain with low hardware requirements – regardless of the network’s throughput, and without trusting any external entity.



You can take a look at this tutorial.

The Warp team at Nethermind is developing a Solidity to Cairo transpiler: Warp.

StarkNet does not natively support EVM.


StarkNet and StarkEx

StarkEx is a standalone, customizable Layer-2 SAAS for exchanges that uses the STARK proof system in order to provide massive scaling. Several significant exchanges are already using StarkEx in production on Ethereum Mainnet (read more about StarkEx).

StarkNet is a general-purpose network where you can write and deploy your own smart contracts, interact with other contracts, and so on, just like Ethereum. 


Once StarkNet is ready, StarkEx apps may migrate to StarkNet if they so choose.