Key features
Agnostic access to specialized hardware
We lower the entry barrier by providing a single access point to quantum computers across various technologies and types, both emulated and physical. You retain the freedom to test and experiment with your algorithms on our range of compatible SDKs.
Quantum application library (SOON)
Harness the power of hybrid quantum computing without any prior programming or photonic technology knowledge through the integrated quantum application library. Simply input the raw data for your problems, and our service takes care of the rest.
Multi-GPUs powered emulators
Quantum emulation consumption grows exponentially with the number of qubits, making it challenging to run more than a few qubits on your local desktop. Our optimized platforms address this issue by enabling large-scale simulations to design larger algorithms without hardware error concerns. We offer access to leading quantum emulation backends, such as Qsim, Aer, and exQalibur for photonics.
Dedicated Sessions
Start a QPU session then run your quantum jobs without dealing with queuing delays of mutualized hardware. Once a session is out, you keep the trace of your jobs. If you manage a training workshop or want to collaborate with others, you can share sessions among participants with a deduplication system.
Compatible SDKs
Qiskit, for high level programming
Qiskit is a powerful python SDK to design, build and run quantum algorithms on backends implementing universal quantum computation. Scaleway provides a python package to send Qiskit circuits on either Aer or Qsim emulation backends.
Cirq, to design NISQ circuits
Cirq is an open-source Python framework for writing and running programs on quantum computers. Developed by Google’s quantum software team, it is now supported by a dynamic open-source community beyond Google. The QaaS service is accessible through a Python package to run your circuits on the Qsim emulator.
Perceval, for photon-based computing
Perceval is a quantum photonic development kit written in Python and maintained by Quandela to design and run circuits on your local machine or on a remote computer. Scaleway is embedded into Perceval as a built-in provider to run quantum circuits on real or emulated photonic QPUs. To design your photonic circuits, you can rely on a set of Jupyter Notebook tutorials.
Our photonic QPU offers

Photonic Quantum Computing (PQC), also known as Linear Optical Quantum Computing (LOQC), is a promising approach that leverages photons as quantum information carriers. It harnesses the power of linear optical techniques and the unique properties of photons. In this field, qubits are represented using photons in various ways, such as Fock state, spin, or polarization, enabling great flexibility in building complex quantum algorithms.

Photonic computing is advancing rapidly, with emerging approaches like Measurement-Based Quantum Computing (MBQC), known for their error tolerance, being closely studied.

Computers and emulators by Quandela, a French startup founded in 2017, pushs photonic quantum computing further through two technologies. First a single-photon source for generating indistinguishable photons and the use of two distinct fibers (called "modes") to represent qubit states, providing resilience and precision, this approach is known as Dual Rail Encoding (DRE). These two technologies are simulated through Perceval, an SDK dedicated to this kind of quantum computer.


Platform nameManufacturerQuantum carrierSpeedGate fidelityMaximal qubit count*IntegrationsPrice
qpu:ascellaQuandelaPhoton (Dual Rail Encoding)4Mhz single-photon eventsT: 99.6%±0.1
CNOT: 99%±0.8
Toffoli: 90%		6 photons,
12 modes*		Perceval, APIFree during beta
Limited to 1h per month
qpu:altairQuandelaPhoton (Dual Rail Encoding)3Mhz single-photon eventsT: TBD
CNOT: TBD
Toffoli: TBD		10 photons,
20 modes*		Perceval, APIFree during beta
Limited to 1h per month

* 1 qubit = 1 photon + 2 modes

Our emulated QPU offers

Quantum emulators are significantly valuable in the current and upcoming periods, serving as primary means to design quantum algorithms, free from constraints associated with quantum hardware.

Emulators are time saving tools that offer to researchers and programmers an accessible platform to explore and develop quantum algorithms, eliminating the reliance and limitation of physical quantum computers.

Platform nameSimulation backendSimulation instanceMax estimated qubits count*IntegrationsPrice
sim:sampling:p100exQaliburNvidia Tesla P10029 photons,
80 modes**		Perceval, API3,12€/h
Billed per min
sim:sampling:h100exQaliburNvidia H10031 photons,
192 modes**		Perceval, API6,55€/h
Billed per min
sim:ascellaQuandeLibCSIMD CPU6 photons,
12 modes**		Perceval, APIFree during beta
Limited to 1h per month
sim:altairQuandeLibCSIMD CPU10 photons,
20 modes**		Perceval, APIFree during beta
Limited to 1h per month
aer_simulation_2l4Aer v0.14.12 x Nvidia L433Qiskit, API1,5€/h
Billed per min
aer_simulation_2l40sAer v0.14.12 x Nvidia L40S34Qiskit, API2,58€/h
Billed per min
aer_simulation_4l40sAer v0.14.14 x Nvidia L40S35Qiskit, API5,6€/h
Billed per min
aer_simulation_8l40sAer v0.14.18 x Nvidia L40S36Qiskit, API11,2€/h
Billed per min
aer_simulation_h100Aer v0.14.1Nvidia H10033Qiskit, API2,52€/h
Billed per min
aer_simulation_2h100Aer v0.14.12 x Nvidia H10034Qiskit, API5,04€/h
Billed per min
aer_simulation_pop_c16m128Aer v0.14.1POP2_HM_16C_128G32Qiskit, API0,82€/h
aer_simulation_pop_c32m256Aer v0.14.1POP2_HM_32C_256G33Qiskit, API1,65€/h
aer_simulation_pop_c64m512Aer v0.14.1POP2_HM_64C_512G34Qiskit, API3,3€/h
qsim_simulation_l40sQsim v0.21Nvidia L40S32Cirq, Qiskit, API1,4€/h
Billed per min
qsim_simulation_h100Qsim v0.21Nvidia H10033Cirq, Qiskit, API2,52€/h
Billed per min
qsim_simulation_pop_c8m64Qsim v0.21POP2_HM_8C_64G32Cirq, Qiskit, API0,41€/h
qsim_simulation_pop_c16m128Qsim v0.21POP2_HM_C16_128G33Cirq, Qiskit, API0,82€/h
qsim_simulation_pop_c32m256Qsim v0.21POP2_HM_32C_256G34Cirq, Qiskit, API1,65€/h
qsim_simulation_pop_c64m512Qsim v0.21POP2_HM_6C4_512G35Cirq, Qiskit, API3,3€/h

* Based on the Quantum Volume in double precision, up to 1 additional qbit in single precision
** One qubit = 1 photon + 2 modes

In the current landscape, quantum computers are prone to produce errors during operations as illustrated in Figure 1. This Noisy Intermediate Scale Quantum (NISQ) era will persist until the emergence of Fault-Tolerant Quantum Computing (FTQC). In the meantime, emulation stands as the only way to simulate error-free qubits.

Emulation into the quantum ecosystem
Access to boosted quantum emulators

Quantum volume is a good tool to evaluate capacity of a platform. We run growing circuits until we reach hardware limitations.

We create square circuits, e.g. 24x24 or 30x30, denoting the number of qubits and the number of quantum gates (depth) respectively. These gates are randomly selected from Pauli X, Y, Z, Hadamar and 2-qubits control gates like CX and CZ. These squared-circuits, designed on Qiskit and Cirq SDKs, were executed on popular local setups and on our Quantum as a Service across different hosted platforms (always in state vector with double floating precision).

Benchmark for 50k shots on aer CPU

As you can notice in Figure 2, our CPU-based QaaS platforms ran from 2x to 10x faster than local setups on a few qubit count.

Moreover, in local setups we encounter limitations by running squared-circuits with more than 30 emulated qubits due to excessive memory requirement. In contrast, our 512GB memory platform enables us to extend up to 34 qubits in less time than a 30 qubits in local setup.

Benchmark for 50k shots on aer GPU

To go further, we also benchmarked our GPU-accelerated platforms. As depicted in Figure 3, it completely outperforms CPU-based platforms, a 34-qubits circuit passed from 150s on our C64512M to 12s on our 8-L80S configuration offering a 12x boost.

Moreover, these multi-GPUs platforms allow us to reach up to 36 qubits on squared-circuits, which is more than convenient to push forward quantum computing exploration. As our benchmark is double floating precision, it is possible to reach one additional qubit by switching to single floating precision.

Benchmark for 50k shots on qsim CPU

We also ran some benchmarks on Qsim emulation. Qsim is a full wave function simulator written in C++. It uses gate fusion, vectorized instructions and OpenMP multi-threading to achieve state of the art state vector simulations of quantum circuits. Figure 4 shows us really top performance on CPU setups. The average performance is twice time faster than Aer emulation and offers an additional qubit for the same hardware configuration.

For even faster Qsim execution, we provide GPU platforms powered by Nvidia cuQuantum.

Benchmark for 1000 shots on square-circuits

When we run Quandela’s Exqalibur, which is dedicated to photonic emulation, we can notice that our GPU-accelerated platforms exhibit a substantial computation speedup for equivalent circuit size, taking less than a second compared to 241 seconds for Apple M2 or 695 seconds for an Intel i7.

Moreover, in local setups we encounter limitations by running squared-circuits with more than 11 photons due to excessive memory requirement. In contrast our H100 GPU-accelerated platform, enables us to extend up to 31 photons in 2h.

Use cases with quantum advantage

Quantum machine learning (QML) algorithms like quantum neural networks and variational quantum algorithms (VQA) provide advantages in handling large datasets and optimizing complex models. This emerging field can combine algorithm and data from classical and/or quantum fields leading to exciting hybrid approaches.

Even if we are still in the Noisy Intermediate Scale Quantum (NISQ) era, we can already leverage quantum circuits to enhance dimensional reduction and data encoding. This new kind of pre-processing can greatly increase your dataset’s entropy.

Simulating the behavior of molecules and materials at the quantum level is computationally intensive and often intractable for classical computers. Quantum algorithms can potentially model molecular interaction with high precision. Leading to advancements in drug discovery, science of materials and climate modeling.

Quantum algorithms are efficient at solving optimization problems such as path finding, isomorphism finding or finance, which involve finding the best solution from a large set of possible solutions. They explore multiple possibilities simultaneously, allowing for more efficient solutions to complex challenges.

dropdown illustration
Cheat Sheet

Install Qiskit SDK with Scaleway package

bash

$ pip3 install --upgrade pip
$ pip3 install qiskit qiskit-scaleway

    Use Qiskit to run quantum circuits

    quantum.py

    # Create a QPU session
    from qiskit import QuantumCircuit
    from qiskit_scaleway import ScalewayProvider

    provider = ScalewayProvider(
    project_id="scw-project-id",
    secret_key="scw-secret-key"
    )

    backend = provider.get_backend("aer_simulation_2l40s")
    session_id = backend.start_session()

    # Get and configure your quantum circuit
    qc = QuantumCircuit(2)

    qc.h(0)
    qc.cx(0, 1)
    qc.measure_all()

    # Finally, run the circuit and get your job result
    job = backend.run(qc, shots=1000, session_id=session_id)
    result = job.result()
    print(result.get_counts())

    # Close your session once your work is done
    backend.stop_session(session_id)

    Install Cirq Scaleway package

    bash

    $ pip3 install --upgrade pip
    $ pip3 install cirq-scaleway

      Use Cirq to run quantum circuits

      quantum.py

      import cirq
      from cirq_scaleway import ScalewayQuantumService

      # Connect with the quantum service
      service = ScalewayQuantumService(
      project_id="scw-project-id",
      secret_key="scw-secret-key"
      )

      # Create a new virtual device
      qsim_simulator = service.device(name="qsim_simulation_pop_c16m128")

      # Run a time-limited session on this device
      with qsim_simulator.create_session() as session:
      qubit = cirq.GridQubit(0, 0)
      circuit = cirq.Circuit(cirq.X(qubit) ** 0.5, cirq.measure(qubit, key="m"))

      # Run the circuit over the session
      result = session.run(circuit, repetitions=1000)
      print(result)

      Install Perceval SDK

      bash

      $ pip3 install --upgrade pip
      $ pip3 install perceval-quandela==0.11

        Use Perceval to run quantum circuits

        quantum.py

        # Create a QPU session
        import perceval as pcvl
        import perceval.providers.scaleway as scw

        session = scw.Session(
        platform="sim:sampling:h100",
        project_id="scw-project-id",
        token="scw-secret-key"
        )

        session.start()

        # Get and configure your remote processor
        proc = session.build_remote_processor()
        proc.set_circuit(pcvl.Circuit(m=2, name="circuit") // pcvl.BS.H())
        proc.with_input(pcvl.BasicState("|1,1>"))

        # Finally, run the circuit and get your job result
        sampler = pcvl.algorithm.Sampler(proc)
        job = sampler.samples(10)
        print(job)

        # Close your session once your work is done
        session.stop()

        FAQ

        Quantum computing is a field of computing that relies on quantum mechanics to perform specific kinds of computations much more efficiently than classical “binary” computers.

        A quantum digit, or qubit / qbit, is the elementary storage unit in quantum computing. Qubits, like classical bits, are based on physical phenomena to store data.

        A photon is a single particle of light which has numerous interesting attributes, named observables, to store data, like polarization, speed, color, spin… As quantum particles, photons can be entangled together and their observables can be superposed.

        Quandela produces photonic quantum computing, so photons are used to store and manipulate data. These photons are manipulated through tiny light fibers called modes and operations are performed with beam splitters and phase shifters. Handling a photon directly instead of an abstract qubit allows it to take a significant advantage on computation.

        Logical qubit is an abstract information storage built to be fault tolerant and time resilient to quantum operations. It is built on a set of hundreds or thousands of physical qubits. Physical qubits tend to be closer to the quantum material and more unstable.

        Of course, be patient! We plan to release new platforms based on new underlying hardware, or new underlying emulation layers.

        Yes, have a look onto the Perceval github page.

        Noisy Intermediate Scale Quantum era corresponds to our current period where quantum computers are too noisy and error prone to make relevant computations. That is why quantum emulators are emerging to allow developers to design and experiment quantum algorithms.

        Beyond noisy qubits and noisy computations, the emergence of the Fault Tolerant Quantum Computing era introduces logical qubits and logical gates to bring robustful computation for complex algorithms. There is a long before reaching this quality of quantum computation.

        In depends, Aer and Qsim are open sourced but Quandela’s exQalibur is close source

        Let us know, you can contact us via our Slack community.

        We are really open minded about this topic. If your company works on a real or emulated QPU and wish to make it available , please, let us know, and can contact us via our Slack community.