Skip to main content

Qall: Composable execution for hybrid computing

PyPI version License

Qall is an open-source framework for defining, packaging and executing hybrid workflows across heterogeneous compute resources, from CPUs and GPUs to quantum processors (QPU) and emulators.

Qall separates what a computation needs from where it runs, making workflows portable, reproducible and reusable across infrastructure.

Qall was initially developed around hybrid quantum-classical workloads, where classical and quantum resources must work together as part of a single computation.

/!\ Qall is still in Alpha phase and under active development.

Why Qall?

Hybrid workloads increasingly combine different types of compute (CPU, GPU, QPU) alongside storage, network and infrastructure management.

CPU loading
       │
       ▼
GPU preprocessing ───► QPU execution
       │                 │
       └───────┬─────────┘
               ▼
        CPU postprocessing

A single workload may need to move between CPU, GPU and QPU resources, while handling environments, credentials, queues, intermediate data and execution state.

Qall lets these steps be described as one computation, while infrastructure selection and execution are handled separately.

Qall provides a common execution model:

  • Tasks & Workflows: define computations and compose them into graphs
  • Resource Profiles: map abstract requirements to available infrastructure
  • Artifacts & Checkpoints: persist intermediate state and enable partial recomputation
  • Workers: ad-hoc adapter to connect quantum circuit to execution backends
  • Registry: version and distribute computation objects

Quickstart

Install Qall SDK & CLI:

pip install qall

Write your pythonic workflow:

from qall import task, workflow

def _get_value(val):
    return 0.5 * val

@task(min_cpu=2)
def prepare_data(val : float):
    return [0.1, 0.2, 0.3] * _get_value(val)

@workflow
def main():
    data = prepare_data(0.5)
    print(f"Prepared data: {data}")

Run it locally:

qall run my_workflow.py --local

Run it remotely :

qall login scaleway --project-id=YYYY

qall run my_workflow.py

The same execution model is designed to extend from local development to managed heterogeneous infrastructure.

Qall-compliant provider Integration status CPU GPU QPU emulated QPU
Local ⚙️ ⚙️ ❌ ❌ Qsim, Aer
⚙️ CUDA-Q
Scaleway (website) ⚙️ ⚙️ ⚙️ Quandela, Pasqal, IQM, AQT CUDA-Q, Aer, Qsim

Quantum / hybrid example

Qall can execute quantum circuits from within a classical workflow.

from qall import task, workflow, run
import qiskit

@task(min_qubit=5, qpu_modality="gate_based", requirements=["qiskit"])
def execute_quantum(size):
    qc = qiskit.QuantumCircuit(size)
    qc.h(0)

    for i in range(1, size):
        qc.cx(i - 1, i)

    qc.measure_all()

    result = run(qc, shots=100)
    return result.get_counts()

@workflow
def main():
    result = execute_quantum(3)
    return result

The same workflow can combine classical computation and quantum execution without exposing provider-specific infrastructure in the workflow code.

qall.run(): hide the execution plumbing. Calling a quantum backend typically involves more than submitting a circuit: provider and SDK compatibility; authentication and credentials; backend discovery and selection; session or execution context creation; circuit submission and job management; queues and asynchronous execution provider-specific result formats; connection and execution state.

What Qall takes care of

Qall is designed for developers who want to stay hands-on with their workloads without having to build and maintain the infrastructure required to execute them:

Developers focus on Qall takes care of
What to compute Where and how it runs
Writing and evolving Python code Packaging, executing the workload and manage result storage
Defining what each step needs Matching and installing requirements to available resources
Calling a quantum circuit Handling the backend-specific execution
Combining CPU, GPU and QPU steps Orchestrating the different resources
Controlling resource usage Managing the execution infrastructure

For example, instead of embedding provider-specific backend and execution logic into a workflow, a developer can simply write:

result = qall.run(circuit, shots=100)

Qall handles the execution details required by the selected backend while keeping the workflow independent from a specific infrastructure.

For infrastructure providers, the same abstraction works in the other direction: a provider integrates its resource once with Qall, rather than exposing its execution model directly to every application.

Design principles

Separate computation from infrastructure

Workflows describe requirements, not necessarily physical resources.

@task(min_cpu=2, min_memory_gb=16)
def preprocess():
    ...

The actual resource can be selected later according to the active execution profile.

Computations as reusable artifacts

Qall represents workflows as content-addressed computation graphs.

This enables:

  • deterministic versioning
  • deduplication
  • workflow sharing
  • partial recomputation
  • reusable computation components

Heterogeneous execution

The same workflow model can combine:

  • CPU workloads
  • GPU workloads
  • quantum emulators
  • QPUs
  • any other specialized execution hardware

Quantum computing is one of the first use cases driving this model.

Project status

Qall is an early-stage open-source project under active development.

The APIs and execution model are evolving. The project is currently intended primarily for experimentation, development and feedback from the quantum computing community.

Qall is maintained by Scaleway's Quantum team as an open-source project for heterogeneous and hybrid computing.

The project is designed around open interfaces and infrastructure-agnostic abstractions, with the goal of making hybrid workloads easier to build, execute and share.

Metadata

Release files for qall 0.1.11

For a detailed explanation of source distributions (sdists) and built distributions (wheels), please see the package formats documentation.

Source distribution (sdist)

Source distribution for qall 0.1.11
File Size Uploaded Provenance Actions
qall-0.1.11.tar.gz 111.8 kB Without provenance Details for qall-0.1.11.tar.gz

Built distribution (wheel)

Table of built distributions (wheels) for qall 0.1.11
File Interpreter ABI Platform Actions
qall-0.1.11-py3-none-any.whl Python 3 none any Details for qall-0.1.11-py3-none-any.whl

Total release size: 307.2 kB

Release files / qall-0.1.11.tar.gz

Download URL qall-0.1.11.tar.gz
Size 111.8 kB
Tags Source
SHA-256 checksum
How to use checksums
bff4a36db3586840a1cfcce26d8728663a899625ab809e7bc77dcfe960e9c2e2
BLAKE2b-256 checksum
How to use checksums
86119f8fa796b7cb061326f73f339e2525475f19834c0d8dc3e0cbacc300fa2e
Upload date
Uploaded using Trusted Publishing?
What is trusted publishing?
No
Uploaded via twine/6.2.0 CPython/3.9.25

Release files / qall-0.1.11-py3-none-any.whl

Download URL qall-0.1.11-py3-none-any.whl
Size 195.5 kB
Tags Python 3
SHA-256 checksum
How to use checksums
19b537de35ed060a376c3082c351c8307667bbbf6fd6bae2591252ad9d5e440b
BLAKE2b-256 checksum
How to use checksums
1ee48f6b5a6999657b9591123316fbf5a326c6702020eddb4202f1c783e2c3a2
Upload date
Uploaded using Trusted Publishing?
What is trusted publishing?
No
Uploaded via twine/6.2.0 CPython/3.9.25

Security for qall 0.1.11

Provenance

Provenance describes where a file came from. On PyPI, provenance is shared via attestations, which provide a verifiable record of the build or publishing details. View details, limitations and caveats.

No provenance found

None of the files in this release were uploaded with provenance metadata.

A note on package security

PyPI is a repository for distributing packages, not a service for auditing them. While third-party security researchers and our staff do their best to detect and remove malicious packages, PyPI cannot guarantee the quality, security or suitability of any given package.

To learn more about protecting yourself from malicious actors, visit our package security documentation.

Anthropic, PBC Visionary sponsor Bloomberg Visionary sponsor Hudson River Trading Visionary sponsor Meta Visionary sponsor NVIDIA Visionary sponsor Microsoft Sustainability sponsor Depot Continuous Integration AWS Cloud computing and Security Sponsor Datadog Monitoring Fastly CDN Google Download Analytics Sentry Error logging StatusPage Status page