Solution

Atlantic

Managed STARK Proving Infrastructure

Generate traces, request proofs, batch jobs, and access StarkWare SHARP through Atlantic. Build proof-backed applications without operating prover infrastructure yourself.

Documentation

Discover Atlantic

AI coding skills for Atlantic are available — install them in your AI coding assistant to get context-aware help building with this product.

Get AI Skills →

Supported VMs

Run Cairo Programs Through Atlantic

Atlantic runs user-submitted Cairo programs as part of a managed STARK proving workflow. You provide the Cairo program and inputs. Atlantic handles execution, trace generation, proof submission, and verification routing.

Bring Your Cairo Program: Submit Cairo 0 or Cairo 1 programs through Atlantic without operating the execution and proving infrastructure yourself.

Execution Before Proving: Atlantic executes the program, generates the trace, and prepares the job for the selected prover.

Flexible Runtime Support: Whether you need speed or advanced features, Cairo’s dual VM support—via Rust or Python—lets you tailor execution to your needs.

Atlantic gives teams a managed API for turning Cairo program executions into verifiable STARK proofs.

Choose Your Cairo Runtime: Rust VM vs Python VM

Atlantic gives developers flexibility when executing Cairo 0 and Cairo 1 programs by supporting both Rust VM and Python VM environments.

Rust VM - Modern Extension

The Rust-based Cairo VM offers high performance and faster trace generation, making it the preferred choice for most use cases. It’s especially effective for Cairo 1 programs. However, custom hints are not yet supported in Rust VM for Cairo 0, so it’s best suited for standard program execution without advanced hint logic.

See example

Python VM - Legacy Support

For Cairo 0 programs that require custom hints or specific input configurations, the Python-based VM provides full compatibility. While it may run slower than the Rust VM, it supports a broader range of advanced features and complex logic.

See example

Available Provers

SHARP Service

Your Gateway to StarkWare’s Proven Prover InfrastructureAtlantic is the seamless interface to StarkWare’s powerful SHARP (Shared Prover) system—used in production for years to generate secure, scalable STARK proofs for Cairo programs. With SHARP, developers can focus on building, not infrastructure.

Battle-Tested Infrastructure: Proven at scale, SHARP powers some of the largest ZK applications in production today.

Full Python VM Compatibility: Supports Cairo 0 with full custom hinting via the Python VM.

Automated Trace Handling: No manual steps—Atlantic manages trace generation and proof requests behind the scenes.

Multi-Target Proof Verification: Verify proofs on Ethereum (L1), Starknet (L2), or off-chain.

Flexible Layout Support: Compatible with a wide range of Cairo layouts, including those optimized for appchains and recursive proving

Stone Prover

For Specialized, Custom ZK SolutionsLooking for more control or enterprise-specific capabilities? The Stone Prover is available through Atlantic for tailored zero-knowledge proof workflows.

Ideal for Private & Enterprise Chains: Customizable infrastructure for specialized deployments.

Custom Cairo Implementations: Build and prove bespoke Cairo programs beyond public tooling limits.

Configurable Proving Pipelines: Fine-tune proof generation to meet unique performance or security requirements.

Need something custom?Reach out to our team to request access and explore what the Stone Prover can unlock for your use case.

Supported Verifiers

SHARP & Stone Verifiers

Verify proofs on EthereumVerify your StarkWare SHARP and Stone proofs on Ethereum using the same verifier trusted by other projects leveraging SHARP and Stone. Mutualize verification costs, reduce overhead and ship faster.

Integrity Verifier

Verify Proofs Natively on StarknetIntegrity is a zero-knowledge proof verifier built to operate directly within the Cairo Virtual Machine, enabling fast, trustless STARK proof verification on Starknet. It's the backbone for scalable Layer 3s, custom appchains, and advanced ZK applications—all without ever leaving L2.

Native Cairo VM execution

Reduced verification costs

Fully composable via the Starknet Fact Registry

Ideal for ZKML, storage proofs, and hyperscaling solutions

Unlock the next level of Starknet scalability with Integrity.See more about Integrity

Need a verifier deployed elsewhere?Utilize the STARK proof verifier on Ethereum Mainnet or let's collaborate to enable proof verification for your EVM compatible Layer 2, Layer 3, or App-Chain.

Key Benefits

Use Cases

Start building today!

Mocked dev environment with instant testnet access

Comprehensive API suite

No upfront payments or credit cards

Personalized support from the Herodotus team