List of Developer Tooling projects on Starknet (2026)

SNF Faucet is a testnet faucet for the Starknet Sepolia network. It distributes test ETH and STRK tokens to developer wallet addresses upon request. It allows developers to fund test accounts for smart contract development and testing without acquiring mainnet tokens.

Starkzap is a TypeScript SDK for integrating Starknet-based Bitcoin, stablecoin, and DeFi features into applications. It provides four modules covering embedded wallets, gasless transactions, DeFi yield products, and token operations, with support for web and mobile platforms. It allows developers to add Starknet functionality to existing apps without building blockchain infrastructure from scratch.

Subgraphs implement flexible blockchain indexing through TypeScript, enabling developers to create custom GraphQL APIs from smart contract data. The system processes on-chain events and provides queryable endpoints with webhook support and automated deployment capabilities.

Mirror implements real-time data streaming pipelines that sync blockchain data directly into databases and message queues. The system enables point-and-click configuration for multiple data destinations while providing unlimited access without per-query fees.

A developer toolkit to build, test, deploy, and run custom blockchain data indexers and GraphQL APIs on the SubQuery Network, helping developers deliver fast, flexible data for dApps.

Topper is a fiat-to-crypto on-ramp and crypto-to-fiat off-ramp delivered through an embeddable widget and developer APIs for business partners and wallets. Consumers buy crypto directly to a self-custodial wallet using cards, digital wallets, or bank transfers, and sell crypto to receive fiat on a linked debit card. The product supports recurring purchases and integrates via a web SDK, mobile SDK, REST API, webhooks, and single sign-on for partner applications.

Sphere API is a developer toolkit providing RESTful endpoints and SDKs for embedding global stablecoin payments into third-party platforms. It supports payment processing, fiat and crypto conversions, and multi-chain transfers, allowing businesses to build on-ramp, off-ramp, and settlement functionality without extensive engineering. The toolkit is used by platforms seeking to embed payment rails across multiple blockchains and stablecoins.

OpenZeppelin Contracts is a library of modular and reusable smart contracts available for Ethereum-compatible blockchains in Solidity and for Starknet in Cairo, implementing standards like ERC20 and ERC721 with focus on security, gas efficiency, and best practices.

A secure operations platform for smart contract development that enables secure automation, monitoring, and management of blockchain applications across 30+ networks.

CoinTool is a no-code blockchain toolbox that enables token creation, batch token distribution, and wallet management across multiple EVM and non-EVM networks. Users deploy standard token contracts, send tokens to multiple addresses in one transaction, generate wallets in bulk, check allowances, and query airdrop eligibility through a browser-based interface without writing code.

A browser extension displaying real-time gas price information across Bitcoin, Solana, and over 80 EVM-compatible networks.

Sats Connect is a JavaScript SDK enabling web applications to connect to Bitcoin wallets. The library implements the WBIP001 standard for wallet connection, transaction signing, account management, and supports Bitcoin Layer 1, Stacks, and Starknet interactions.

Xverse API is a Bitcoin data and infrastructure API for developers. The service provides Bitcoin RPC access, Ordinals indexing, Runes support, BRC-20 token data, portfolio and transaction history, swap aggregation, and Runes minting and etching services for building Bitcoin applications.

Stone Prover is the STARK-proof generation system that powers StarkWare's products. The system generates cryptographic proofs that verify computational integrity while maintaining high performance.

Stwo Prover is a next-generation STARK prover that implements the Circle STARK protocol. It processes blockchain transactions with efficiency and lower costs.

STRK20 is a privacy framework that brings shielded balances and private transfers to ERC-20 assets on Starknet. It operates at the protocol level and is accessed from the user's wallet, letting holders shield a balance, transact privately, and unshield in one action. The framework shares a viewing key with an independent auditor to enable scoped, compliant disclosure when legally required.

A unified API infrastructure providing read and write connectivity to multiple blockchains and DeFi protocols. The system supports transaction signing, data querying, price discovery, trade decoding, compliance checks, and liquidity management across DEXs, bridges, lending platforms, staking protocols, oracles, and NFT marketplaces. The platform uses a modular architecture enabling developers to interact with various chains and protocol endpoints through standardized API calls.

Belong SDK provides developers with APIs and tools to integrate NFT-based token gating and access management into applications. The framework supports multichain functionality, gasless minting, and verification of NFT access credentials across supported networks while offering comprehensive error handling and security features.

Drops Airdrop Tracker monitors wallet addresses across multiple blockchain networks to identify unclaimed cryptocurrency airdrops, providing eligibility checks and Telegram notifications. The platform tracks airdrops on Ethereum, Solana, Cosmos, Aptos, Sui, Starknet, Bitcoin, and TON without requiring wallet connections.

Thoth functions as a security toolkit for Cairo and Starknet, providing bytecode analysis, disassembly, and decompilation capabilities for smart contract review. The tool enables security teams to inspect low-level code execution and identify potential vulnerabilities in deployed contracts.

Cairo-fuzzer implements automated testing techniques for Cairo and Starknet smart contracts, identifying edge cases and security vulnerabilities. The system uses input mutation to generate test cases, allowing developers to discover potential exploits during development rather than after deployment.

Octopus performs security analysis on WebAssembly modules and blockchain smart contracts across multiple platforms including Bitcoin, Ethereum, NEO, and EOS. The tool enables comprehensive code inspection for vulnerability detection and contract verification.

WARF tests WebAssembly runtimes for security issues through automated fuzzing techniques. The tool focuses on improving resilience in WebAssembly virtual machines, parsers, and execution environments by systematically identifying edge cases and unexpected inputs.

Sui-fuzzer implements automated testing for Sui blockchain smart contracts, detecting security vulnerabilities through input manipulation techniques. The system tests contract execution paths systematically, providing developers with insights into edge cases and potential security flaws before deployment to the Sui network.

Sedge is a one-click setup tool for PoS network/chain validators and nodes that helps with the configuration and deployment of validators for Ethereum and other networks.

starknet.go is a Golang library for Starknet and Cairo that allows developers to interact with the Starknet network, submit transactions, and call smart contracts from Go applications.

StarkWeb is a TypeScript library that connects applications to the Starknet blockchain. It provides interfaces for data retrieval, transaction submission, and smart contract interaction.

AVNU Paymaster is a developer tool that enables gas fee flexibility on Starknet, allowing users to pay gas in any supported token or enabling developers to fully sponsor user transactions. It removes onboarding friction by eliminating the requirement to hold native tokens.

Dojo Engine implements a provable game engine through Cairo smart contracts, enabling fast onchain game development with built-in components for state management and game logic.

StarknetKit is a developer toolkit that lets applications integrate Starknet wallet connections, including an embedded web wallet that onboards users with only an email address. It provides session keys for automated transaction signing, paymaster support for customizable or sponsored gas fees, and multicall functionality to bundle several transactions into one signature. Developers use it to connect decentralized applications to Ready and other Starknet wallets without requiring downloads or seed phrase management.

Python framework for building selective blockchain indexers. Includes code generation, ORM integration, and multiple datasource support with TimescaleDB and GraphQL integration.

Ready-to-use blockchain data API service exposing extensive blockchain data collections through GraphQL interfaces, from generic to application-specific datasets.

GraphQL IDE for interacting with DipDup APIs, featuring a query editor, interactive explorer, and documentation integration for improved developer experience.

Cartridge VRF provides atomic, verifiable randomness through cryptographic proofs for onchain games on Starknet. The system processes VRF requests and responses within single transactions using Stark curve verification and Poseidon hashing, enabling synchronous random value generation without multi-transaction delays.

Cairo Programming Language provides a way to write programs that can prove their computations are correct without revealing the actual data. It uses Rust-like syntax to help developers create smart contracts for Starknet and build applications that need mathematical proofs of correctness. The language includes tools for testing, debugging, and generating proofs, making it simpler for developers to build trustworthy blockchain applications without deep cryptography knowledge.

Garaga provides efficient elliptic curve operations and SNARK verification for Cairo and Starknet through optimized modular arithmetic circuits. Users can verify Groth16 and Honk proofs on-chain, perform multi-scalar multiplication across multiple curves, execute pairing operations for BN254 and BLS12-381, and verify ECDSA, Schnorr, and EdDSA signatures. The system enables smart contract verifier generation for various proof systems and provides maintained contracts for RISC Zero, SP1, and drand verification.

Walnut Debugger is a web-based transaction debugger and simulator for Starknet smart contracts, enabling developers to inspect variable states at each execution step and simulate transactions before on-chain deployment. The tool supports source-code-level debugging via contract verification, call trace inspection, and gas profiling against the CairoVM.

Walnut EVM is an open-source transaction debugger and simulator for EVM-compatible chains, supporting Ethereum, Arbitrum, Base, Optimism, Linea, and Katana. The tool traces transaction execution, enables re-simulation with custom calldata, and provides gas profiling; it can be self-hosted against any debug-capable RPC endpoint.

Cairo Playground is a browser-based interactive environment for exploring the CairoVM and writing Cairo code, allowing developers to experiment with Cairo, Sierra, and CASM with step-by-step execution debugging. The tool is hosted on cairovm.codes and targets Starknet and Cairo developers who want to prototype or test contract logic without a local setup.

Storage Proof API provides developers with programmatic access to generate and verify storage proofs within applications. The API abstracts cryptographic complexity and integrates storage proof validation logic through a well-defined interface, allowing applications to implement cross-chain data verification without specialized knowledge of proof systems.

Herodotus Data Processor implements a framework for defining data sets and executing verifiable computations over blockchain data. The system uses STARK proofs and storage proofs to validate computation correctness, enabling applications to perform complex data processing while maintaining cryptographic integrity across blockchain networks.

Integrity Verifier implements STARK proof verification directly on Starknet for Layer 3 scalability. The system enables efficient validation of cryptographic proofs within the Starknet ecosystem, allowing developers to build advanced trust-minimized applications with enhanced verification capabilities on the network.

Starknet ID SDK provides JavaScript libraries for identity and domain resolution, enabling dApp integration with naming services. The toolkit implements profile data retrieval, domain encoding/decoding, and multicall optimization through standardized APIs and React components.

Kakarot implements a complete EVM in Cairo, enabling existing Solidity smart contracts to run on Starknet. The system combines STARK-based cryptography with full EVM compatibility, allowing developers to deploy and execute Ethereum applications within Starknet's high-performance environment while maintaining code compatibility.

Keth implements chain-agnostic EVM proving that generates ZK proofs of EVM block execution in real-time. The system can help optimistic rollups transition to ZK, reinforce existing ZK-rollups with multiple proof systems, and power ZK-bridges for cross-chain interoperability, all while leveraging Starkware's STARK technology for efficient proof generation.

Kakarot on Bitcoin enables Ethereum-compatible ZK-rollups secured by Bitcoin using OP_CAT and other opcodes. It allows the verification of ZK proofs directly on Bitcoin, enabling trust-minimized bridging of BTC to rollups and unlocking native DeFi capabilities while maintaining Bitcoin's security guarantees.

A suite of open-source tools that implement the SNIP-14 standard on Starknet, allowing NFTs to function as smart wallets that can hold assets and interact with dApps.

Starknet Scaffold is a developer toolkit for building decentralized applications on the Starknet network. It provides project bootstrapping, smart contract templates, and pre-configured tooling for contract deployment and frontend interface development, reducing setup overhead for Starknet dApp development.

Tokenbound Accounts is an open-source toolkit that enables developers to integrate ERC6551 and SNIP-14 token-bound account standards into their applications. The suite includes an SDK for Starknet and an explorer interface for querying and interacting with token-bound account contracts on-chain.

Foundry is a toolkit for Ethereum blockchain development written in Rust. It features four main components: Forge for testing and deploying smart contracts, Cast for interacting with blockchain networks, Anvil for running a local Ethereum node, and Chisel for Solidity REPL. Designed for performance and efficiency, Foundry supports both Solidity and Vyper languages with capabilities including fuzz testing, debugging, and RPC forking, all in a unified developer experience.

Starknet Foundry provides a development environment for building applications on Starknet. It includes specialized tools for compiling, testing, and deploying Cairo contracts in a Starknet environment. The toolkit facilitates efficient development workflows with features like test automation, debugging capabilities, and network interaction tools. Built with the same focus on speed and developer experience as the original Foundry, Starknet Foundry enables developers to create reliable and secure applications for the Starknet ecosystem.

Cast is a command-line interaction capabilities for EVM smart contracts, enabling transaction execution and chain data retrieval. The system provides Swiss Army knife functionality for blockchain interactions through standardized RPC interfaces.

Chisel is an interactive Solidity REPL environment through real-time code evaluation, enabling rapid prototyping and debugging. The system provides verbose feedback and immediate execution for Solidity development workflows.

Anvil is a fast local Ethereum development node through JSON-RPC compliance, enabling rapid testing and development workflows. The system provides local blockchain simulation with forking capabilities and pre-funded development accounts.

StarkZap SDK is a developer toolkit for integrating Starknet wallet, token, and DeFi features into web and mobile applications. It provides modular components for social login via Privy and Cartridge Controller, gasless transactions through AVNU paymaster, ERC-20 token operations, native staking, and transaction batching across React, React Native, and Node.js environments.

Lambdaworks implements cryptographic primitives used to build proof systems like SNARKs and STARKs, with comprehensive backends for various proving systems, field extensions, and compatibility with different frontends.

Cairo-VM is a Rust implementation of the Cairo virtual machine, supporting the execution of Cairo programs that can generate proofs of execution. It provides significant performance improvements over the original Python implementation.

A Rust implementation of the STARK proving system, compatible with Starknet's Stone prover. It enables the creation of zero-knowledge proofs of computational integrity with high performance.

A compiler that converts Cairo's Sierra code to machine code via MLIR and LLVM, enabling much faster execution of Cairo programs through native compilation.

Starknet Foundry is a toolkit for testing and deploying tools for Starknet smart contracts through a command-line interface. The toolkit enables developers to write, test, and deploy Cairo contracts with built-in testing frameworks and deployment utilities.

Scarb is a package manager and build tool for the Cairo programming language. The tool handles compilation, dependency management, and project configuration for Cairo applications and Starknet contracts. The system implements standardized project structures and builds processes for Cairo development.

Starknet Libraries provide development interfaces for interacting with Starknet blockchain from multiple programming languages. The libraries include starknet.py for Python, starknet.jvm for JVM languages, starknet.swift for Swift applications, starknet-js for Javascript. Each library implements methods for reading blockchain state, sending transactions, managing accounts, and interacting with smart contracts.

Karnot is a rollup-as-a-service infrastructure with automated deployment pipelines, enabling rapid Starknet app chain creation with production-grade tooling. The platform provides comprehensive monitoring, auto-scaling RPC endpoints, and integrated bridge infrastructure while maintaining modular architecture for custom settlement and data availability layers.

Karnot CLI is a command-line tool for rapid Madara app chain deployment, facilitating initialization, execution, and monitoring of Starknet-based chains. The system provides automated configuration management and integrated explorer functionality for local development environments.

Starknet Devnet is a local testnet for Starknet development written in Rust. It allows developers to test Starknet applications locally with features including forking network states, account impersonation, L1-L2 interactions, predeployed contracts, block manipulations, and time manipulations.

Starknet Rivet is a developer wallet for the Starknet ecosystem. It provides developers with tools to set up local Starknet testing environments, manage accounts, explore blocks and transactions, deploy contracts, and connect to dApps. The wallet simplifies local development and testing while maintaining compatibility with both Devnet-js and Devnet-rs.

Starknet Hardhat Plugin integrates Starknet development into the Hardhat environment. It enables developers to compile, deploy, and interact with Starknet smart contracts using JavaScript. The plugin supports testing through JavaScript, simplifies contract deployment, and facilitates seamless interaction with Starknet networks, enhancing the developer experience and improving workflow efficiency for those building on Starknet.

Calimero Network provides tools for building self-sovereign applications that store data locally on user devices. These applications use client-side validation to verify actions, secure encryption for protecting communications, and local data vaults to maintain user control. Developers can create applications using standard programming languages without specialized cryptography knowledge.

Pathfinder is a full node implementation for Starknet that gives users a safe and independently verifiable view into the Starknet network. Built in Rust, it calculates Patricia-Merkle Trie roots block-by-block and confirms them against Ethereum L1, enabling local contract code and storage verification without relying on third-party sources.

Privacy Pools implements compliant privacy-preserving transactions on Ethereum using zero-knowledge proofs and an Association Set Provider. The protocol allows users to deposit assets publicly and withdraw them privately to new addresses while excluding illicit actors to maintain compliance.

starknet-rs is a Rust library for Starknet that enables developers to build applications that connect to and interact with the Starknet blockchain.

Starkli is a command-line interface tool for interacting with the Starknet blockchain, built on the starknet-rs Rust library. It enables developers to query network state, manage accounts and keystores, and execute transactions including contract declarations, deployments, and invocations. The tool supports Ledger hardware wallets, configurable RPC providers, shell completions, and profile-based environment management.

Scaffold-Stark is a developer toolkit that provides a forkable Starknet application stack through pre-built React hooks, Web3 UI components, and an integrated Cairo smart contract deployment pipeline. The framework bundles Starknet Foundry, Starknet-React, NextJS, and Starknet.js with a local devnet and prefunded test accounts.