Release notes

What’s new in Qaptiva HPC 0.6.0

Release on October 2026

Qaptiva HPC Requirements

A HPC cluster with a compatible sofware stack:

  • Supported CPU architectures: Intel / AMD / ARM

  • RHEL 8 or 9, SLES 15 (or compatible OS)

  • Slurm scheduling system with OpenMPI (with CUDA or HIP support - if relevant)

  • Python version 3.10 to 3.14 included

New distributed (approximate) emulator

This release features CppMPS, a distributed Matrix Product State (MPS) simulator implemented with a C++ back-end and taking advantage of multi-core and multi-nodes architectures. Message Passing Interface (MPI) protocol is used to handle communication between the distributed resources used to store and manipulate quantum states. The simulator offers to exactly simulate larger quantum systems and circuits as long as a maximum entanglement rate parameter (maximum bond dimension) is not reached while performing the simulation. Otherwise the emulation becomes approximate. The MPS system is distributed between multiple computing nodes, which allows to emulate quantum circuits more efficiently by leveraging the capabilities of distributed computing resources. Compared to MPS (the pure Python implementation), simulating large, highly entangling circuits with CppMPS can significantly speed-up the emulation runtimes. Though, it is important to note that CppMPS does not implement all the features MPS does yet. Please refer to its documentation to have a look over its features. Two notebooks have also been added to illustrate the usage of the CppMPS QPU.

Extended gate-set for the NISQCompiler

NISQCompiler now supports the following gate sets in addition:

  • “IBM” gate set has been updated to support different processor families, such as “IBM_NIGHTHAWK”, “IBM_HERON”, “IBM_FALCON” and “IBM_EAGLE”. The legacy architecture is still supported through the “IBM_LEGACY” gate set.

  • “IQM” gate set has been updated, replacing the RX(pi/2) gate by PRX gate. The legacy architecture is still supported through the “IQM_LEGACY” gate set.

  • “AQT” as a new preset gate set, tailored to AQT’s trapped-ion based MARMOT architecture.

  • “IONQ” as a new preset gate set, tailored to IonQ’s trapped-ion based Aria and Forte architecture.

In addition, a new module qat.lang.vendors has been added which contains the gate sets of known QPUs, and also the definition of the gates that are not included in the default gate set of Qaptiva. Currently, the included gates are as follow:

  • PRX gate from AQT and IQM’s gate set.

  • RXX gate from AQT’s gate set.

  • ZZ gate from IBM, IonQ and Quobly’s gate set

  • ECR, RZZ and SX gates from IBM’s gate set.

  • GPi, GPi2 and PMS gates from IonQ’s gate set.

  • K gate from Quobly’s gate set.

Initial parameters for Simulated Annealing

This release features the method get_sa_initial_parameters() that allows to obtain initial parameters when tackling combinatorial optimization problems with Simulated Annealing via the SimulatedAnnealing QPU. These parameters are obtained by inspecting the qubo matrix representation of the problem to estimate the temperature to match an acceptance rate of Monte Carlo updates at the beginning of the simulation. These parameters can be then fine-tuned to increase performances.

Updated features

  • Simulator qat.qpus.CNoisy now supports observable measurement in deterministic mode.

  • Simulator qat.qpus.CNoisy now supports stochastic simulations.

  • Munge has been disabled from the license authentification. The permission and authorization files have been removed.

  • The nb_processes argument in DLinAlg and DNoisy has been renamed to nb_nodes to better reflect its usage.

  • Added a new method to_latex() that returns the string representation of a circuit in its latex representation with qcircuit. See the method documentation for information regarding some latex display parameters [BRQ-1886].

Bug fixes

  • Fixed Y observable calculation for noisy deterministic mode in DNoisy

  • Fixed stochastic sampling method in DNoisy when non-unitary noise model is used. [BRQ-1965]

  • Fixed the problem where the meta data of a batch not being inherited in the BatchResult in noisy stochastic simulation with DNoisy [BRQ-1964]

  • Fixed a bug in noisy stochastic simulation where the same seed is used for different trajectories, causing a biais in the simulation and sampling. [BRQ-1963]

  • Fixed a SegFault in DNoisy while measuring an observable (nbshots > 0) in noisy stochastic simulation in the case where the number of terms is not equal to the number of qubits in the observable. [BRQ-1962]

  • The HardwareModel created by make_quobly_hardware_model() was not serializable and therefore not usable in Qaptiva Access. This is now fixed.

  • Simulator qat.qpus.CLinalg does not ask for GPU to the Qaptiva HPC license server anymore when run in CPU mode.

  • Simulator qat.qpus.CLinalg now asks for the correct number of qubits to the Qaptiva HPC license server.

  • Fixed the inclusive scan algorithm used in CLinalg in various cases.

  • Qaptiva to Qiskit converters to_circ() method was not working properly with intermediate measurement, where setting the parameter include_measure to true was deleting the intermediate measurement. The problem is now fixed (include_measure will only remove the final measure).

What’s New in Qaptiva HPC 0.5.4

Released in August 2026

Qaptiva HPC Requirements

An HPC cluster with a compatible software stack:

  • Supported architecture: x86_64

  • Supported operating systems: RHEL 8 or RHEL 9 (or compatible distributions)

  • Slurm workload manager with OpenMPI

  • Python versions 3.10 through 3.14

Fixes

  • Fixed an issue in GPU sampling mode with nbshots > 0 and more than 20 qubits in CLinalg. [BRQ-2000]

Known issues

  • An issue causing inaccurate result when simulating a noisy job with non-unitary noise (for instance amplitude damping) using DNoisy in stochastic mode is discovered. This will be fixed in the coming release.

What’s New in Qaptiva HPC 0.5.3

Released in August 2026

Qaptiva HPC Requirements

An HPC cluster with a compatible software stack:

  • Supported architecture: x86_64

  • Supported operating systems: RHEL 8 or RHEL 9 (or compatible distributions)

  • Slurm workload manager with OpenMPI

  • Python versions 3.10 through 3.14

Fixes

  • Fixed an issue in GPU sampling mode with nbshots > 0 in CLinalg. [BRQ-1993]

Known issues

  • An issue causing inaccurate result when simulating a noisy job with non-unitary noise (for instance amplitude damping) using DNoisy in stochastic mode is discovered. This will be fixed in the coming release.

What’s New in Qaptiva HPC 0.5.2

Released in July 2026

Qaptiva HPC Requirements

An HPC cluster with a compatible software stack:

  • Supported architecture: x86_64

  • Supported operating systems: RHEL 8 or RHEL 9 (or compatible distributions)

  • Slurm workload manager with OpenMPI

  • Python versions 3.10 through 3.14

Fixes

  • Fixed an issue with the license mechanism when using CLinalg on a cluster without any GPU.

  • Fixed an issue with an exception raised when using CNoisy on a cluster without any GPU.

Known issues

  • An issue causing inaccurate result when simulating a noisy job with non-unitary noise (for instance amplitude damping) using DNoisy in stochastic mode is discovered. This will be fixed in the coming release.

What’s New in Qaptiva HPC 0.5.1

Released in June 2026

Qaptiva HPC Requirements

An HPC cluster with a compatible software stack:

  • Supported architecture: x86_64

  • Supported operating systems: RHEL 8 or RHEL 9 (or compatible distributions)

  • Slurm workload manager with OpenMPI

  • Python versions 3.10 through 3.14

Fixes

  • The HIP version of Qaptiva HPC now supports AMD GPUs based on the gfx942 and gfx950 architectures.

  • Fixed a “CUDA Invalid Configuration” error that could occur when running a simulation with more than 32 qubits on a single GPU.

What’s new in Qaptiva HPC 0.5.0

Release on March 2026

Qaptiva HPC Requirements

A HPC cluster with a compatible sofware stack:

  • Supported CPU architectures: Intel / AMD / ARM

  • RHEL 8 or 9, SLES 15 (or compatible OS)

  • Slurm scheduling system with OpenMPI

  • Python version 3.10 to 3.14 included

Extended distributed noisy emulation

  • The distributed noisy simulator in Distributed Qaptiva now support stochastic noise simulation. The class DNoisy can now additionally accept an argument sim_method which can be set to stochastic to run the noisy simulation in stochastic mode. The default simulation mode remains deterministic. An additional argument n_sample is accepted by DNoisy when running in stochastic mode, to represent the number of trajectories to be shot for each job in stochastic mode. This new simulation method is supported on both CPU and GPU simulation. For more information on this simulation method, please refer to the DNoisy section.

  • The distributed noisy simulator in Distributed Qaptiva now supports observable measurement. The class representing a noisy simulator, DNoisy can now accept a Job that measures an Observable at the end of the emulation in its submit function. To learn how to create an Observable, please refer to the Creating observable section. This new feature is supported in both deterministic noise emulation and the newly added stochastic noise emulation.

Updated features

  • Performance improvement in CLinalg for CPU observable mode nbshots==0, accompanied by a behaviour change (by default, the expected term values are not returned individually anymore).

  • In MPS and MPO, the automatic linearization of the circuit is now faster. Defaut Nnizer parameters have been changed to give fast (but suboptimal) linearization. These parameters can be overriden by the user.

  • Function get_substate() was not documented. This function should be used when implementing a QPU using Distributed Qaptiva.

  • DMPSTraj now features high order time evolution methods (WI and WII). See parameter evol_method.

  • Plugin NISQCompiler now supports “QUOBLY” as a preset gate set, tailored to Quobly’s silicon-based spin qubit architecture.

Bug fixes

  • Lifting a Schedule into a Job (i.e., using qat.core.Schedule.to_job()) with no option passed had an undefined behavior. This function has been updated to have the same behavior as lifting a Circuit into a Job (sampling mode, all qubits are measured).

  • Plugin Remap was not able to compile empty circuits. This problem is now fixed

  • Plugin NISQCompiler was not able to format properly the result when the number of qubits available in the circuit was not matching the number of qubits in the topology.

  • The tool designed to check the license server did not inherit from the Qaptiva HPC global configuration. This is now fixed.

What’s new in Qaptiva HPC 0.4.0

Qaptiva HPC Requirements

A HPC cluster with a compatible sofware stack:

  • Supported CPU architectures: Intel / AMD / ARM

  • RHEL 8 or 9, SLES 15 (or compatible OS)

  • Slurm scheduling system with OpenMPI

  • Python version 3.9 to 3.13 included

Release 3 on October 2025

Fixes

  • Qaptiva-hpc license service missing information (server side)

  • Qaptiva-hpc license check not using config.ini file (compute side)

  • Qaptiva HPC license installation updated to use Boost 1.75.0 on RHEL 8

  • Missing files in dqlm-clinalg-hip

  • Ignore remote controlled qubit when constructing state iterator in qat.core

Release 2 on September 2025

Multi-GPU emulators

The distributed emulators in Distributed Qaptiva now supports single-node multi-GPUs emulation. The classes DNoisy and DLinAlg can now additionally accept an argument use_GPU which will perform the emulation with GPUs on the node when set. The argument nb_processes_per_node or the sbatch parameter ntasks-per-node can be used to configure the number of GPUs that will be used on the node. This new feature enables the utilization of GPU computing power within HPC clusters to conduct large-scale simulations.

Connection with Qaptiva Access

It is now possible for a Qaptiva Access server to offload jobs to an HPC cluster. This feature requires a Qaptiva Appliance.

Only Qaptiva HPC simulators can be offloaded in such a way. This includes CLinalg, DLinAlg and others.

If this is the prefered mode of execution, please consider settings default_node_type=COMMODITY in the configuration file qlmaas.ini.

Moreover Qaptiva HPC must be installed on the HPC cluster nodes wished to be used for offload. These nodes must also be tagged with the feature corresponding to qaptiva_hpc_constraint in the slurm_commands.ini config file. By default this means having a QAPTIVAHPC feature.

A new analog emulator (single-node)

A new QPU is available for analog quantum computing: QutipQPU using the QuTiP library. It performs a time-dependent evolution of a quantum state under a Hamiltonian specified in a Schedule. The QPU supports executing various types of Hamiltonians like spin, bosonic and fermionic schedules and observables (spin and bosonic can be combined). It also includes schedules with stochastic parameters and, alternatively, a noise description of the environment in terms of Lindblad operators.

New gate-based emulators (single-node)

The tensor network QPUs MPS and MPO are now part of Qaptiva-HPC. Based on a compressed representation of the wavefunction or density matrix, they allow for efficient simulations of short-depth and low-entangling quantum circuits even for large numbers of qubits, and constitute one of the leading numerical tools for quantum computer emulation. They can be used for noiseless and noisy simulations, as well as in the Schrödinger (state evolution) and Heisenberg (observable evolution) pictures.

Updated features

  • DMPSTraj now supports describing initial states with the '+' and '-' symbols, corresponding to the two eigenstates of the X operator, in addition to '0' and '1'. In addition, an initial state can also be provided as a Numpy vector, allowing arbitrary initial state description for small number of qubits.

  • SAMPLE shots from CLinalg will now have a more natural ordering (non-aggregated shots will be stored in the order in which they were simulated)

What’s new in Qaptiva HPC 0.3.0

Released on March 2025

Qaptiva HPC Requirements

A HPC cluster with a compatible software stack:

  • Supported CPU architures: Intel / AMD (ARM work in progress)

  • RHEL 8 or 9, SLES 15 (or compatible OS)

  • Slurm scheduling system 23.02 (or above) with OpenMPI

  • Python version 3.9, 3.10, 3.11 or 3.12

A new distributed noisy emulator

Distributed Qaptiva now features a distributed noisy emulator, DNoisy. It builds upon the the highly optimized distributed emulator DLinAlg and offers the same benefits of of multi-core (with OpenMP parallelism) and multi-nodes architectures, but will aditionally accept a hardware model describing the noise model to be applied to the circuit. DNoisy can then perform the exact simulation of such noisy quantum circuits by storing the entire density matrix describing the qubits’ state and distributing it across multiple nodes in a cluster, overcoming the memory limitation of a mono-node architecture.

A new distributed analog simulator

As of the present release, Qaptiva HPC now features a first analog simulator, called DMPSTraj. This emulator relies on a Matrix Product State (MPS) representation to perform the computation. It supports both ideal and noisy emulations. Because the noisy emulation is embarrassingly parallel, this emulator can use multiple nodes to emulate all the trajectories, and hence simulate even more qubits.

New compilation plugins

Qaptiva HPC provides new plugins to transpile a quantum circuits. These plugins can be divided in two categories:

  • plugins designed to execute a circuit on real quantum hardware.

  • plugins designed to perform emulation of quantum hardware.

Distributed Qaptiva now provides transpilers to transform a quantum circuit into an equivalent one executable on a real quantum hardware. The transpiled circuit is not equal to the initial circuit but equivalent, meaning that result of the transpiled circuit may require classical processing to retrieve the expected result. Our transpilers are wrapped in plugins, like NISQCompiler, as plugins handle classical postprocessing automatically. Please refer to transpilation section to get more information on our transpilers tools.

Please note that are transpilers cannot transform circuits having more than 20 qubits. If you need to transpile bigger quantum circuits, please consider using a Qaptiva Appliance.

A new plugin RepairPermutation has been added in Qaptiva HPC. Its purpose is to return the qubits to their initial position at the end of a circuit that has been localized. This plugin is important for the new DNoisy emulator since it puts the state probabilities to be sampled back on the diagonal of the density matrix. It is applied by default by DNoisy after the Localizer plugin.

Updated features

  • DLinAlg updated features:

    • Now has an improved parallelism when sampling shots for nbshots > 0

    • Now does the sampling in place, so the number of qubits that can be simulated in SAMPLE mode and OBSERVABLE mode are now the same (No additional memory space needed for sampling)

    • Now supports observable mode with nbshots > 0

    • Removed qubit threshold for Localizer and FusionPlugin in the default plugins

  • CLinalg updated features:

    • Now supports string type psi_0.

    • Now supports observable mode with nbshots > 0 (no need to add ObservableSplitter anymore).

    • Observable mode with nbshots == 0 now sets value_data.

    • Now supports intermediate measurements in GPU simulation.

    • Now supports SAMPLE mode for nbshots > 0 in GPU simulation

  • FusionPlugin will now work even if the circuit contains gates that cannot be fused

Fixes

  • Fixed a segmentation fault in DLinAlg when sampling shots for nbshots > 0

  • Fixed an error in DLinAlg where SWAP gate was not working when there is only one local qubit

  • Fixed aligned_alloc/free in CLinalg on windows for diagonal gates

  • Fixed CUDA n-qbits gate in CLinalg

  • KPTree was generating wrong state prepartions if the state to prepare has a negative amplitude. The state preparation routine KPTree can now generate state preparations having negative real numbers.

First release of Distributed Qaptiva

Version 0.1.0 released on July 2024

What is Distributed Qaptiva

Distributed Qaptiva is the distributed Quantum Appliance developed by Eviden. This appliance is meant to be deployed in a High-Performance Computing (HPC) environment with distributed resources, offering a highly optimized quantum circuit simulation with multithreading and state vector distribution. It features DLinAlg, a distributed Linear-algebra based simulator that extends the mono-node LinAlg simulator in Qaptiva to take advantage of multi-core (with OpenMP parallelism) and multi-nodes architectures. Message Passing Interface (MPI) protocol is used to handle communication between the distributed resources used to store and manipulate quantum states. This simulator offers the possibility to simulate larger circuits, as the complete representation of the state vector can be distributed across multiple nodes in a cluster, which allows us to overcome the memory limitation of a mono-node architecture.

Distributed Qaptiva Requirements

A HPC cluster with a compatible software stack:

  • Compute nodes with AVX512 support (preferably)

  • RHEL 8 or 9 Operating System (preferably RHEL 9.4)

  • Slurm scheduling system 23.02 (or above)

  • Python version 3.9, 3.10, 3.11 or 3.12

  • OpenMPI version 4.1.5 or above

  • CUDA version 11.8 on RHEL 8, 12.4 on RHEL 9

  • Intel oneAPI MKL library