How to run quantum circuits on Quobly Pioneer

Quobly Alloy provides access to Pioneer, Quobly's quantum circuit simulator. Pioneer enables the simulation of quantum circuits using realistic noise models derived from the calibration data and physical characteristics of Quobly's QPUs, helping developers evaluate algorithm performance under hardware-like conditions.

While Pioneer can be executed on a local workstation for small-scale experiments, larger simulations can quickly become computationally demanding. Scaleway QaaS allows you to offload these workloads to dedicated CPU and GPU clusters directly from your Python code, benefiting from pre-configured and optimized execution environments designed for high-performance quantum simulation.

Why use Quobly on Scaleway?

Scaleway provides a seamless bridge between your local Qiskit environment and cloud-based High-Performance Computing (HPC) resources:

Pay only for what you use: Billing starts only when the Platform is fully operational and ready to execute jobs.
GPU acceleration: Instantly provision powerful NVIDIA GPUs, such as H100 or L40S clusters, to accelerate large-scale statevector simulations.
Optimized environments: Pre-configured Platforms are tuned for high-performance quantum simulation, allowing Pioneer to fully leverage the underlying hardware.
QPU-calibrated noise models: Pioneer incorporates noise models derived from calibration data collected on Quobly's QPUs, allowing simulations to closely reflect the behavior of real quantum hardware.
Automatic data compression: Quantum circuits and simulation results are automatically compressed during transfer to reduce bandwidth usage and minimize latency.
Transparent pricing: Resources are allocated on demand. Similar to standard cloud instances, you pay only for the compute resources consumed during your simulations.

How to access Pioneer with Scaleway

Pioneer is accessible through multiple SDKs. Check SDK/Backend compatibility.

In this tutorial, we use Qiskit to execute quantum circuit simulations on Pioneer running on Scaleway Quantum as a Service (QaaS).

To run a simulation remotely, you simply need to switch your Qiskit backend to a Scaleway-hosted emulator.

The following example demonstrates how to run a computation on a Scaleway GPU instance. The workflow is identical to using a local emulator, but the computation happens remotely.

Before you start

To complete the actions presented below, you must have:

A Scaleway account with a valid Project ID
A Scaleway API key (Secret Key)
Python and qiskit installed on your local machine

Install the qiskit-scaleway provider. Refer to the Qiskit Scaleway GitHub repository for more information.
```
pip install qiskit-scaleway
```

Create a file with the following computation script. Replace $SCW_PROJECT_ID and $SCW_SECRET_KEY with your Scaleway Project ID and secret key.

from qiskit import QuantumCircuit
from qiskit_scaleway import ScalewayProvider

# 1. Initialize the Provider
# Ensure you have your credentials ready
provider = ScalewayProvider(
    project_id="$SCW_PROJECT_ID",
    secret_key="$SCW_SECRET_KEY"
)

# 2. Select the Pioneer CPU Platform
# Example platform ID: 'EMU-PIONEER-19PQ-H100' (Pioneer emulator using an Nvidia H100 GPU)
backend = provider.get_backend("EMU-PIONEER-H100")

# 3. Create a Quantum Circuit
# Let's create a Bell state with measurement
qc = QuantumCircuit(2)
qc.h(0)
qc.cx(0, 1)
qc.measure_all()

# 4. No transpilation
# Scaleway QaaS handles the transpilation server-side for you

# 5. Execute on remote emulator
# The job is sent to Scaleway, executed on the GPU, and results are returned compressed.
job = backend.run(qc, shots=10000)

# 6. Get Results
result = job.result()

print("Results:", result)

Save the script. In this example we save it as pioneer.py.
Run the script.
```
python ~/pioneer.py
```

Tip

Refer to the Quantum Computing information page for more details on how emulation platforms and billing work.