Blog
GPU-Optimized Servers for ZK Proofs & Web3 Research
Zero-knowledge proofs (ZKPs) have moved from “clever crypto demo” to production infrastructure: ZK-rollups, privacy-preserving DeFi, and ZK-based identity all rely on generating proofs at scale. That’s a specific hardware problem: parallel compute, huge memory bandwidth, and a predictable environment.
GPU acceleration can substantially shorten proof generation. Ingonyama’s Kroma case study reports about 4× faster Circom proof generation after integrating ICICLE into Tachyon. Separately, ZKProphet reports up to approximately 200× acceleration in its Groth16-focused prover comparison using optimized kernels against CPU baselines.
To sustain those gains, GPUs need well-balanced servers: CPUs to orchestrate the pipeline, ample RAM to keep cryptographic objects in memory, NVMe storage for chain data and proving keys, and networking sized to move state and intermediate data on time.
This is where Melbicom’s GPU-powered dedicated servers come in. We provide dedicated hardware with configurable GPU, CPU, RAM, and storage resources so you can match the server to your prover.
Choose Melbicom— Dedicated GPU servers — 24/7 infrastructure support — Custom configs in 3–5 business days |
Which GPU Setup Is Best for ZK Proofs?
The right GPU configuration for ZK proofs starts with a supported backend and enough VRAM for its peak working set. Compare complete proof latency and throughput, then choose independent GPU workers or distributed proving according to the engine. CPU capacity, host RAM, and data movement must keep pace with that layout.
Groth16’s main kernels are multi-scalar multiplication (MSM) and the Number-Theoretic Transform (NTT). ZKProphet identifies these two primitives as more than 90% of prover runtime for that proof system.
A good GPU layout for ZK proofs focuses on:
- Engine support and throughput. Match the GPU architecture, CUDA backend, and driver requirements, then compare complete proof throughput. CUDA core counts and FP32 ratings alone do not rank prover performance.
- VRAM capacity. SP1’s CUDA backend requires at least 24 GB. ZKsync’s prover guide budgets 24 GB each for its prover and proof compressor, or 48 GB to run them together on one GPU. Choose 48–80 GB cards when the working set or concurrent stages exceed a 24 GB device’s capacity.
- Memory bandwidth. Check both on-device bandwidth and the host-to-GPU path. MSM/NTT performance can also be limited by integer arithmetic or the implementation’s data-transfer strategy.
Topology matters as well, but the available parallelism depends on the engine:
- Independent GPU workers process proofs concurrently for higher throughput.
- Distributed proving can split one execution into tasks across GPUs. SP1 Cluster, for example, distributes shard proofs and recursion tasks across GPU workers before assembling the final proof.
Choose the layout around your goal: more proofs per second from a queue, or lower latency for an individual proof. Each GPU still needs enough memory for its assigned tasks.
What Server Specs Do ZK Provers Need?
A server for large-scale ZK proofs needs CPU capacity for execution and witness generation, enough host RAM for simultaneous workers, and fast access to proving keys and intermediate data. Start with the engine’s requirements, then add the memory and I/O budgets of the workers and node services that will run together.
ZK Prover Server Baseline
Use the following criteria to size a ZK prover server:
| Component | Role in ZK / Blockchain Workloads | Sizing Criteria for Heavy ZK Proofs |
|---|---|---|
| GPU | Runs parallel proving kernels and holds active GPU data | Supported GPU architecture and sufficient VRAM per worker; 24 GB for SP1 CUDA, with 48–80 GB options for larger working sets |
| CPU | Orchestrates proving pipeline, node logic, preprocessing, I/O | Strong single-core performance for execution; core count matched to concurrent witness, wrapping, and node workloads |
| RAM | Stores constraint systems, witnesses, proving keys, node data | Sum concurrent worker budgets plus system and service memory; 256 GB suits the two-GPU SP1 example below |
| Storage | Holds chain data, proving keys, intermediate artifacts, logs | NVMe SSDs for active data; capacity for keys, peak intermediate data, retained history, and rebuild workspace |
| Network | Syncs blockchain state and exchanges data between prover components | Size throughput from data volume and transfer deadlines |
CPU and RAM: Feeding the GPU
Even with aggressive GPU offload, the CPU still:
- Builds witnesses and constraint systems
- Schedules batches and manages queues
- Runs node clients, indexers, or research frameworks
- Handles serialization, networking, and orchestration
Size CPU throughput from the stages that remain on the host. For example, 8 CPU-seconds of preprocessing per proof at 4 proofs per second consumes 32 CPU cores continuously, before wrapping and node services. Add capacity for that concurrent work; single-core performance also matters where execution and trace generation are serial.
RAM is the other hard constraint. Budget for the workers that run simultaneously, then add space for the operating system, node clients, and artifact storage. SP1 Cluster recommends 96 GB for a CPU worker and 32 GB per GPU worker. Colocating one CPU worker and two GPU workers therefore gives a 96 + 2 × 32 = 160 GB worker budget; 256 GB is a practical host configuration for that layout.
Storage and Networking: Moving Proofs and State
For ZK-heavy Web3 stacks, disk and network throughput are first-class design parameters:
- Storage: NVMe SSDs provide fast access to chain state, proving keys, and intermediate data. Size capacity from the active dataset, retained history, and temporary space needed when rebuilding or replaying a workload.
- Networking: Distinguish final proofs from working data. SP1’s wrapped Groth16 proof is roughly 260 bytes, while its cluster can exchange intermediate artifacts larger than 500 MB. Witnesses, traces, keys, and chain state can dominate data movement.
For example, moving a 20 GB dataset in 30 seconds requires 20 × 8 ÷ 30 ≈ 5.3 Gbps of payload throughput, using decimal units. A 10 Gbps port leaves capacity for protocol overhead and concurrent traffic; storage and the path must sustain that payload rate.
Across our dedicated-server range, Melbicom offers servers with up to 200 Gbps per server. Select port speed for the transfer window and a metered or unmetered traffic plan for expected monthly volume. Use BGP options when announcing your own IP prefixes.
How to Select GPUs for Blockchain Research
The right GPU for blockchain and ZK research balances engine compatibility, memory capacity, proof throughput, and total cost. Choose a less expensive card when the workload fits its memory and meets your throughput target. Move to a larger card when additional VRAM enables the circuit size, concurrency, or precomputation your engine needs.

In broad strokes:
- For large working sets, A100 80 GB provides 80 GB of HBM2e and approximately 2 TB/s of memory bandwidth: 1,935 GB/s for PCIe and 2,039 GB/s for SXM.
- For lab clusters and prover workers whose GPU allocations fit within 24 GB, RTX 4090 provides 24 GB of GDDR6X and 1,008 GB/s of peak memory bandwidth.
Economically, this can support a two-tier model:
- Development and research on 24 GB GPUs when the backend and circuits fit.
- Larger-memory workers for jobs that exceed that capacity, alongside smaller cards that still meet production throughput targets.
GPU-accelerated libraries also make software selection part of hardware selection. Ingonyama’s Kroma case study reports 8–10× faster MSM, 3–5× faster NTT, and about 4× faster Circom proof generation after integrating ICICLE into Tachyon, compared with its CPU implementation. Compare complete proof time, including host stages, when choosing hardware for your own prover.
Melbicom can tailor GPU-powered server configurations around GPU model and count, CPU, RAM, storage, and networking for blockchain research workloads.
Key Infrastructure Takeaways for ZK Proofs

For teams designing ZK-proof and blockchain infrastructure, the practical priorities are:
- Choose a supported GPU backend. Compare complete proof latency and throughput, then select the worker layout that serves your concurrency or latency target.
- Budget RAM for concurrent workers. Add CPU and GPU worker requirements, node services, and artifact storage so the active workload stays in memory.
- Size data paths from transfer deadlines. Include keys, witnesses, trace artifacts, and chain state in storage and network planning.
- Use dedicated resources for repeatable testing. Single-tenant GPU servers reserve hardware for you and let you control software versions and competing host jobs.
Building ZK-Proof Infrastructure on Dedicated GPU Servers

Zero-knowledge proofs may be “just math,” but turning that math into scalable Web3 infrastructure is an engineering exercise in compute, memory, and networking. Dedicated GPU servers provide exclusive hardware resources and control over the software stack for research runs and production workers.
As ZK systems evolve, keep the prover version, circuit size, worker layout, and measured bottlenecks in the hardware plan. That keeps research results useful when the same workload moves into production.
Configure Your GPU ZK Server
Choose GPU memory, CPU, RAM, storage, and networking around your prover’s requirements. Custom builds in 3–5 business days support ZK proving and blockchain research.