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]
39k+ lines, async/tokio, zero-copy parsing
IQM, IBM Quantum, QDMI, LUMI, LRZ, Simulator
First-class SLURM + PBS, OIDC auth
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-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.
15 crates, 39k+ 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.
QASM3 parser uses zero-copy techniques for blazing fast circuit loading. Parse megabyte files in milliseconds.
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, compilation, job monitoring, and result histograms. Running right now.
Circuit visualization, backend monitoring, job management
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.