---
title: Run quantum circuits on CUDA-Q
description: Run CUDA-Q quantum runtime on Scaleway's GPU infrastructure using CUDA-Q SDK or Qiskit.
tags: quantum cuda-q qiskit qaas nvidia
dates:
  validation: 2026-02-10
  posted: 2026-02-10
---
import Requirements from '@macros/iam/requirements.mdx'

**CUDA Quantum (CUDA-Q)** is a framework developed by NVIDIA designed for quantum computing applications. It is part of NVIDIA's efforts to integrate quantum computing with classical computing systems, specifically targeting quantum circuit simulation, quantum algorithms, and hybrid quantum-classical workflows. CUDA-Q leverages the power of CUDA (NVIDIA's parallel computing platform) to accelerate quantum computing simulations and provides a foundation for quantum software development that can run on NVIDIA GPUs.

Scaleway QaaS allows you to scale CUDA-Q beyond your local machine. You can execute your emulated computation on dedicated **GPU cluster** (like Nvidia H100, L40S and B300) seamlessly, benefiting from pre-configured MPI setup and optimized environments.

## Why use CUDA-Q on Scaleway?

* **Billed at time:** The billing starting time begins only when the Session is fully operational and the first Job can be executed.
* **Multi-Framework support:** Uniquely, our CUDA-Q platforms are accessible via both **CUDA-Q** and **Qiskit**. You can choose your preferred language while benefiting from the CUDA-Q runtime.
* **On-the-shelf MPI environment:** CUDA-Q benefits from multi GPUs infrastructure via **OpenMPI** but it can be a boilerplate to configure, Scaleway's QaaS handles it for you.
* **Smart compression:** Just like our Aer and Qsim offerings, the platform automatically compresses circuit data and computation results to optimize network throughput and latency.

## How to access via CUDA-Q (Native)

[CUDA-Q](https://developer.nvidia.com/cuda-q/) SDK is the native language to run CUDA-Q runtime. Using the `cuda-q` package allows you to run your circuits directly on our cloud GPUs.

CUDA-Q emulation is accessible through multiple SDKs. [Check SDK/Backend compatibility](/quantum-computing/additional-content/sdk-backend-compatibility/).

<Requirements />

- A Scaleway account with a valid **Project ID**
- A Scaleway **API Key** (Secret Key)

1. Install the `cuda-q` package. Refer to the [NVIDIA documentation](https://nvidia.github.io/cuda-quantum/latest/using/quick_start.html) for more information.

    ```bash
    pip install cuda-q
    ```

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

    ```python
    import cudaq

    # 1. Initialize Scaleway target
    cudaq.set_target('scaleway',
            machine="EMU-CUDAQ-8B300SXM",
            project_id="<$SCW_PROJECT_ID>",
            secret_key="<$SCW_SECRET_KEY>"
    )

    # 2. Create a CUDA-Q kernel
    @cudaq.kernel
    def bell():
        qubits = cudaq.qvector(2)
        h(qubits[0])
        x.ctrl(qubits[0], qubits[1])
        mz(qubits)

    # 3. Run the kernel on Scaleway cloud
    counts = cudaq.sample(bell, shots_count=1000)
    ```
4. Save the script. In this example we save it as `cudaq.py`.

5. Run the script.
    ```bash
    python ~/cudaq.py
    ```
## How to access via Qiskit

<Requirements />

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

1. Install the `qiskit-scaleway` provider. Refer to the [Qiskit Scaleway GitHub repository](https://github.com/scaleway/qiskit-scaleway/) for more information.

    ```bash
    pip install qiskit-scaleway
    ```

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

    ```python
    from qiskit import QuantumCircuit
    from qiskit_scaleway import ScalewayProvider

    # 1. Initialize Provider
    provider = ScalewayProvider(
        project_id="$SCW_PROJECT_ID",
        secret_key="$SCW_SECRET_KEY"
    )

    # 2. Select a CUDA-Q Backend
    # Scaleway bridges the Qiskit circuit to the CUDA-Q engine automatically
    backend = provider.get_backend("EMU-CUDAQ-H100")

    # 3. Create & Run Circuit
    qc = QuantumCircuit(2)
    qc.h(0)
    qc.cx(0, 1)
    qc.measure_all()

    job = backend.run(qc, shots=1000)

    print("Counts:", job.result().get_counts())
    ```

4. Save the script. In this example we save it as `cudaq.py`.

5. Run the script.
    ```bash
    python ~/cudaq.py
    ```

<Message type="tip">
  Refer to the [Quantum Computing information page](/quantum-computing/additional-content/quantum-computing-information/) for more details on how emulation platforms and billing work.
</Message>