Rust-Native Quantum Compilation for HPC
Blazing-fast compilation, deep framework integration, and first-class European HPC support. Not a replacement — a platform that makes your circuits run everywhere.
pip install arvak
arvak[qiskit] · arvak[cirq] · arvak[pennylane] · arvak[all]
57k+ lines, async/tokio, zero-copy parsing
IQM, IBM, CUDA-Q, QDMI, Neutral-Atom, Simulator + Plugins
First-class SLURM + PBS, OIDC auth
Compiler is never the bottleneck. 85K–950K gates/s on production hardware.
Choose your path. Each gets you running circuits in under a minute.
import arvak # Build a Bell state circuit = arvak.Circuit(2) circuit.h(0) circuit.cx(0, 1) circuit.measure_all() # Run on simulator result = arvak.run(circuit, backend="sim", shots=1000) print(result.counts) # {'00': 498, '11': 502} # Compile for IQM hardware compiled = arvak.compile_circuit(circuit, target="iqm", optimization_level=2)
from qiskit import QuantumCircuit from arvak.integrations.qiskit import ArvakProvider # Your existing Qiskit circuit — no changes needed qc = QuantumCircuit(2, 2) qc.h(0) qc.cx(0, 1) qc.measure_all() # Run on any Arvak backend provider = ArvakProvider() backend = provider.get_backend('sim') # or 'iqm', 'ibm' job = backend.run(qc, shots=1000) print(job.result().get_counts()) # Convert between frameworks import arvak print(arvak.list_integrations()) # {'qiskit': True, 'qrisp': True, 'cirq': True, 'pennylane': True}
# ~/.arvak/config.yaml site: lumi scheduler: type: slurm partition: q_fiqci account: project_462000xxx backend: type: iqm endpoint: https://qpu.lumi.csc.fi auth_method: oidc defaults: shots: 1024 optimization_level: 2
use arvak_ir::Circuit; use arvak_hal::Backend; use arvak_adapter_sim::SimulatorBackend; #[tokio::main] async fn main() -> anyhow::Result<()> { let circuit = Circuit::bell(); let backend = SimulatorBackend::new(); let job_id = backend.submit(&circuit, 1000).await?; let result = backend.wait(&job_id).await?; println!("Results: {:?}", result.counts); Ok(()) }
Deep, bidirectional integration. Not a replacement — a platform that makes your circuits portable.
Use Arvak as a Qiskit backend. Bidirectional circuit conversion via QASM3. Auto-discovery plugin.
pip install arvak[qiskit]
High-level quantum types, automatic uncomputation. ArvakBackendClient for Qrisp sessions.
pip install arvak[qrisp]
LineQubit and GridQubit support. ArvakSampler and ArvakEngine for Google Cirq.
pip install arvak[cirq]
ArvakDevice for QNode support. Automatic differentiation and QML workflows.
pip install arvak[pennylane]
Write once, run on any HAL-Contract compliant backend. Simulator to supercomputer.
First-class SLURM and PBS support. OIDC authentication. LUMI and LRZ as first-class citizens.
Arvak integrates natively with HPC job schedulers. Define your site configuration once, then submit quantum jobs through the same workflow as classical HPC workloads. OIDC authentication, partition mapping, and job persistence included.
site: lumi scheduler: type: slurm partition: q_fiqci account: project_462000xxx backend: type: iqm endpoint: https://qpu.lumi.csc.fi auth_method: oidc oidc_provider: https://auth.csc.fi defaults: walltime: "00:30:00" shots: 1024
# Authenticate via OIDC arvak auth login --provider csc # Submit quantum job to LUMI arvak run circuit.qasm \ --backend iqm \ --shots 1024 # List available backends arvak backends # Compile for target hardware arvak compile circuit.qasm \ --target iqm \ --output compiled.qasm
The Arvak CLI compiles, runs, and manages quantum circuits from your terminal.
19 crates, 57k+ lines. Production-ready gRPC service with comprehensive Python client.
Async-first design with Tokio. All backend operations are non-blocking, perfect for concurrent job management.
Full pipeline — layout, routing, basis translation, optimization — in microseconds. 85K–950K gates/s on production hardware. The compiler is never the bottleneck.
QubitId, GateOp, and Circuit types catch errors at compile time. No runtime surprises.
All core types are thread-safe. Run compilations in parallel, share backends across threads.
Production-ready gRPC server with 7 RPCs, 3 storage backends, Prometheus metrics, and OpenTelemetry tracing.
First-class Python support via PyO3. Use from Jupyter notebooks or integrate with existing Qiskit code.
from arvak_grpc import ArvakClient client = ArvakClient("localhost:50051") # Submit a Bell state circuit qasm = """ OPENQASM 3.0; qubit[2] q; h q[0]; cx q[0], q[1]; """ job_id = client.submit_qasm(qasm, "simulator", shots=1000) # Wait for results result = client.wait_for_job(job_id) print(f"Counts: {result.counts}") # {'00': 502, '11': 498} client.close()
from arvak_grpc import AsyncArvakClient import asyncio async def main(): client = AsyncArvakClient("localhost:50051", pool_size=10) # Submit 10 jobs concurrently job_ids = await asyncio.gather(*[ client.submit_qasm(qasm, "simulator", shots=1000) for _ in range(10) ]) # Wait for all results results = await asyncio.gather(*[ client.wait_for_job(jid) for jid in job_ids ]) await client.close() asyncio.run(main())
# Basic gRPC client pip install arvak-grpc # With export support (Arrow/Parquet) pip install arvak-grpc[export] # With DataFrame support pip install arvak-grpc[polars] # With visualization pip install arvak-grpc[viz] # Everything pip install arvak-grpc[all]
Circuit visualization, ESP fidelity analysis, device topology, qubit mapping, VQE optimization, compilation, and job monitoring. Running right now.
| Name | Status | Backend | Shots |
|---|---|---|---|
| Bell State #12 | completed | simulator | 1024 |
| GHZ State #11 | completed | — | 2048 |
| X+Bell Circuit #10 | running | simulator | 512 |
| Dual Entangl. #9 | pending | — | 4096 |
| Superposition #8 | pending | simulator | 1024 |
Circuit visualization, ESP fidelity, device topology, qubit mapping, VQE convergence, compilation, job management
No install required. See Arvak in action directly on our servers.
Live compilation shootout. Pick a circuit, hit Run, and watch Arvak compile against Qiskit, Cirq, and Qrisp on the same server in real time.
Request a demo key and SSH into our server. Run real quantum compilation workloads interactively from your terminal.
A complementary platform for the quantum ecosystem. Not a replacement.
Three paths into Arvak. Pick the one that fits.
Run algorithms on any backend without rewriting code.
Deploy Arvak on your cluster in minutes.
Build on the Rust core or use the gRPC API.
Arvak is open source. We welcome contributions, feedback, and collaboration.