survey

Open access

Quantum Software Components and Platforms: Overview and Quality Assessment

Authors:

Manuel A. Serrano,

José A. Cruz-Lemus,

Ricardo Perez-Castillo,

Mario PiattiniAuthors Info & Claims

ACM Computing Surveys, Volume 55, Issue 8

Article No.: 164, Pages 1 - 31

https://doi.org/10.1145/3548679

Published: 23 December 2022 Publication History

All formats PDF

Abstract

Quantum computing is the latest revolution in computing and will probably come to be seen as an advance as important as the steam engine or the information society. In the last few decades, our understanding of quantum computers has expanded and multiple efforts have been made to create languages, libraries, tools, and environments to facilitate their programming. Nonetheless, quantum computers are complex systems at the bottom of a stack of layers that programmers need to understand. Hence, efforts towards creating quantum programming languages and computing environments that can abstract low-level technology details have become crucial steps to achieve a useful quantum computing technology. However, most of these environments still lack many of the features that would be desirable, such as those outlined in The Talavera Manifesto for Quantum Software Engineering and Programming. For advancing quantum computing, we will need to develop quantum software engineering techniques and tools to ensure the feasibility of this new type of quantum software. To contribute to this goal, this paper provides a review of the main quantum software components and platforms. We also propose a set of quality requirements for the development of quantum software platforms and the conduct of their quality assessment.

1 Introduction to Quantum Computing

In 1982, Nobel laureate Richard Feynman asked: “What kind of computer are we going to use to simulate physics?” [43], so introducing the idea of the quantum computer and launching the second quantum revolution. Over the last two decades, our understanding of “quantum computers” has expanded dramatically, as efforts to realize such an “exotic” computer have made steady but remarkable progress [88]. Quantum computers have the potential to solve tasks that classical computers can never solve in a practical amount of time. Indeed, quantum computers exponentially speed up solutions to problems that would otherwise require massive parallel computing, thus allowing us to simulate nature more efficiently and precisely than with classical platforms [19].

Quantum computers offer us completely new solutions in multiple business areas [67]: economics and financial services, chemistry, medicine and health, supply chain and logistics, energy, agriculture, and many more. Quantum computing is also having an impact in different areas of computer science, mainly in security [151], Artificial Intelligence [36, 45, 156] or Natural Language Processing [94]. Besides, several quantum algorithms have been created [4] since the seminal ones [33, 59, 134].

Many technologies have been developed to implement qubits: trapped ions qubits, superconducting qubits, semiconductor-based qubits, photonic qubits, valley qubits, and the like [125]. Several quantum computers are available, using either quantum annealing (e.g., D-Wave¹) or gate-based quantum computing (e.g., IBM Quantum,² Rigetti,³ Google,⁴ etc.) and, recently, their superiority (“supremacy”) over classical ones has been proven [12].

Nevertheless, for quantum computing to become a more effective reality, the mere existence of quantum computers and quantum computer science alone is not enough. As The Quantum Software Manifesto [119] states: “Given the recent rapid advances in quantum hardware, it is urgent that we step up our efforts in quantum software”. Indeed, the recent European Quantum Flagship’s Strategic Research Agenda [38] explicitly urges the investigation of the “development of software stacks to integrate quantum computing into current computing environments”.

A huge effort from both industry and academia has, nevertheless, produced several types of quantum software tools. These software tools, complemented by adequate quantum software engineering techniques, will most likely turn out to be the main driver for a new software engineering “golden age” during the 2020s [120] - just as occurred in previous advances [18].

This main contribution of this paper is twofold. First, it provides an extensive review and analysis of the quantum software technology, ranging from quantum programming languages to quantum tools and libraries. It also analyses the available quantum software simulators, optimizers, error correction tools, and the main vendors in the field. Its second contribution is the definition of the necessary software quality requirements for quantum software platforms, as well as their assessment.

The remainder of this paper is organized as follows: Section 2 presents an overview of quantum software, while Section 3 presents “a quantum technology review” of the quantum programming languages, simulators, optimizers, and so on. Section 4 discusses the functional and non-functional quality requirements proposed for quantum software development platforms. Section 5 presents the main implications for researchers and practitioners. Finally, Section 6 presents an evaluation of software quantum stacks. Lastly, some conclusions and future lines of research are detailed.

2 Quantum Software

This section introduces the role that quantum software plays in the quantum computing technology stack. Firstly, the quantum software layers are explained in Section 2.1. Then, hybrid classical-quantum software is introduced in Section 2.2, and finally, in order to clarify the information provided in the other two subsections, an example of how quantum software is developed is provided in Section 2.3.

2.1 Quantum Software Layers

Quantum computers are complex systems that should not be directly handled by quantum software programmers. Instead, to take advantage of the power of these devices, a stack of layers that approximates the quantum computer to the user have been usually implemented. Figure 1 shows a typical full stack of a quantum computer.

Fig. 1.

Generally, developers work in a user-friendly environment in which a quantum circuit is coded or designed in drag-and-drop environments. These quantum circuits are then converted to an equivalent, intermediate representation in a quantum programming language such as openQASM [28, 29] or pyQuil [136] in order to become a quantum application. Such quantum applications are not yet directly executable by the quantum device and must first be compiled to that system through a compiler that adapts and optimizes the quantum circuit to the quantum processor architecture and to their existing set of quantum gates and operators.

The quantum algorithm compiled for the target platform is enriched with instructions that prevent quantum errors due to decoherence and quantum noise, so that the system is optimized and resilient to errors. This step is usually known as “Quantum Error Correction” (QEC).

After this optimization, it is transferred to a hardware compiler that brings the quantum algorithm closer to the target quantum machine by specifying the quantum algorithm in the quantum firmware of the quantum computer. This quantum firmware is the lowest layer of the quantum computer stack and is the one that finally adapts the quantum algorithm to the physical qubits of the quantum processor. This mapping from logical qubits to physical qubits requires technology-dependent optimizations (see Figure 1).

This generic stack is adapted to the different commercial environments and existing quantum computers. These commercial stacks usually include the compilation, error correction, and optimization in the bottom layers (i.e., those closest to the physical device) and include intermediate layers that facilitate the developer's task by adding method libraries and optimized algorithms for various applications such as artificial intelligence, chemistry, or optimization.

All of this “software toolchain” (with the set of pertinent input–output transformations), of course, requires the appropriate software to translate and optimize both applications and abstraction layers [26].

2.2 Hybrid Classical-quantum Software

Quantum computing is not an all-in-one technology. Due to the intrinsic nature of quantum computing, it is suitable to address a particular kind of problem, but not every problem. Indeed, for some problems, quantum computers may suffer from the same limitations as classical ones [2], while at other times the task is quite simple - so there is no reason to use a more expensive technology to address what classical computers can still perform quite adequately.

Therefore, new software architecture will probably seek to integrate classic and quantum software into so-called “hybrid information systems” [115]. These are systems which support some business operations that are implemented with classical programming languages, but which perform calls to quantum algorithms. The classical software runs in classical computers (i.e., the controller or the driver part) while quantum software runs in quantum computers (the responder part) that are typically located in the cloud. Since the computation power of the today's quantum computers is still limited, one solution is to use several quantum machines in a distributed quantum computing architecture [42].

Furthermore, hybrid software still uses the classical controller part for supporting two important tasks: the cost function and the shots management [91]. The cost function refers to the part in which the quantum answer (based on qubits’ measures) is translated as a meaningful answer to a real-world problem. The term “shots management” refers to the estimation and control of how many executions of the quantum algorithm are needed to get a reliable answer, since it is based on a probabilistic search space. According to [90], hybrid software still faces obstacles in terms of code portability, tool integration, program validation, and the orchestration of workflow development. For example, concerning code portability, there are already some intermediate representations like QIR (Quantum Intermediate Representation) [50].

2.3 An Example of Quantum Software Development

In order to clarify the concepts stated in this section, we provide an example of how quantum software is developed and executed by following different steps (see Figure 2).

Fig. 2.

The chosen example for illustrating this process is well-known in quantum computing: the quantum entanglement of two qubits. This phenomenon produces an effect on quantum particles which makes the state of a qubit be determined by the state of another one to which it is entangled. There is no such an effect in que Classical Mechanics.

The following mathematical formulas represent the probability of two qubits of being in any of the four possible states when measured at the same time.

\begin{equation*} \left| {{\rm{\Psi }}\rangle = \alpha } \right|00\rangle + \beta \left| {01\rangle + \gamma |10\rangle + \delta } \right|11\rangle \qquad \hbox{with }{\left| \alpha \right|}^2 + {\left| \beta \right|}^2 + {\left| \gamma \right|}^2 + {\left| \delta \right|}^2 = 1 \end{equation*}

In fact, in the quantum entanglement problem, both β and γ are equal to 0, as the only possible states to be found are | \(00\rangle\) and | \(11\rangle\) , this is, those in which the state of both qubits is the same.

After the problem has been analyzed and properly understood, the following step is to design the corresponding quantum circuit, for which a circuit designer is typically used. Through such designer the different gates are set to construct the circuit (see Figure 3 – right). After the circuit has been designed, it could also be executed on a simulator which will provide the results in different formats, for instance, using histograms with the probabilities of measuring each of the possible states of the qubits (see Figure 3 – middle). To perform these operations, several tools can be used (cf. Section 3.2). Most of these tools can generate the source code of the circuit according to different quantum programming languages, which will be commented in Section 3.1. In the example (see Figure 3 – right), the circuit is transformed into the OpenQASM language.

Fig. 3.

Once the source code is obtained, it is usually integrated into a classical software application which makes use of it. There are two main options for this: embedding the quantum source code on a program developed with a classical programming language (e.g., Python or C#) and use it as a functional part of it or directly execute it on actual quantum machines by using the different services that the vendors provide. In this second case, the most common option is sending the quantum software which is received and enqueued for execution on remote quantum machines. After the execution, a report with the results is sent back to the developers.

3 Overview of the Software Quantum Technology

This section provides a review of the quantum software technology by listing and classifying it in the following subsections: programming languages, simulators, optimizers, error correction tools, tools and libraries, main vendors, and development and run platforms.

3.1 Quantum Programming Languages

Quantum computer programming usually consists of defining a quantum circuit such as the one presented in Figure 4 so that it represents the operations being applied to each of the qubits in the quantum computer. This graphical notation is useful for small examples and for building prototypes, but as the circuit gets bigger it ceases to be practical. As a result, various quantum programming languages have been proposed to make it easier to specify quantum algorithms. These quantum algorithms are usually a translation of the quantum circuit into code, i.e., a sequence of textual programming statements.

Fig. 4.

Fig. 5.

Several quantum programming languages have been proposed in recent years, some of them more oriented to quantum circuits (like the “classical” assembler), while others are closer to high-level languages. In Figure 5 we can see the roadmap of quantum languages as they have been developed through the years, and from which it is evident that in the last few years there has been an explosion of new languages and proposals.

In some of these cases, the new arrivals cannot really be considered as autonomous languages, but rather are libraries built over classical languages or embedded languages (similar to “classical” SQL embedded statements). These libraries can be invoked from general-purpose, classical programming languages such as Python.

Figure 6 provides some examples of quantum algorithms for (a) SILQ qubits superposition⁵ and (b) teleport in OpenQASM.⁶

Fig. 6.

The mainstream quantum programming languages usually follow the imperative or functional paradigms. There are also other languages which are based on object-orientation, circuits, or are even multiparadigm. More information about these programming languages can be found in [46, 54].

3.1.1 Quantum Imperative Programming Languages.

Most of the languages proposed for quantum computing are imperative. Some of the proposals provide a language of their own, usually assembler-based proposals, although most of them are extensions to other general-purpose, classical programming languages, most notably Python.

Table 1 includes information on the various imperative quantum programming languages, including year of invention, name, the classical language on (or to) which the language is based on (or for which it is an extension), level of abstraction, and bibliographical reference(s). The table is based on the one included in [157] but it includes new languages and categories.

Table 1.

Year	Name	Language	Abstraction	Reference(s)
1998	QCL	C	Low	[106]
2000	qGCL	Pascal	High	[129, 161]
2003	Q language	C++	High	[16]
2006	LanQ	C	Low	[97, 98]
2008	NDQJava	Java	High	[154]
2009	Cove	C#	High	[123]
2012	Scaffold	C (C++)	Low/High	[3, 70]
2013	Chisel-Q	Scala	High	[86]
2016	QASM	Assembly language	Low	[108]
2016	FJQuantum	Feather-weight Java	High	[41]
2016	ProjectQ	Python	High	[60]
2016	pyQuil (Quil)	Python	High	[136]
2017	OpenQASM	Assembly language	Low	[28]
2017	cQASM	Assembly language	Low	[76]
2017	Quiskit	Python	High	[5]
2018	IQu	Idealized Algol	High	[111]
2018	Strawberry Fields	Python	High	[78]
2018	Balckbird	Python	High	[78]
2018	QuantumOptics.jl	Julia	High	[80]
2018	Cirq	Python	High	[55]
2018	Q#	C#	High	[141]
2018	Q\|SI>	.Net language	High	[85]
2020	Silq	Python	High	[17]
2020	Jaqual	Assembly language	Low	[100]
2020	OpenQL	C++ / Python	High	[77]
2022	OpenQASM3	Assembly language	Low	[29]

Table 1. Quantum Imperative Programming Languages

Most low-level imperative languages are based on assembler, usually as an evolution or adaptation of OpenQASM, while among the high-level quantum languages there is more variety; nevertheless, the prevalence of Python is evident, whether as a programming language or as a language that incorporates quantum computing libraries. It should be noted, however, that there are multiple proposals associated with other programming languages and platforms, such as Julia, Scala, C++, or .Net framework languages.

3.1.2 Quantum Functional Programming Languages.

Although the mainstream quantum programming languages are generally imperative, there are several proposals which are based on functional programming. Some of these proposals are new languages - as is often the case with proposals based on the lambda calculus - but many others are designed as extensions of functional programming languages, such as Haskell or F#.

Table 2 presents the information of the main functional quantum programming languages, using the same headings as Table 1. Some programming languages support both imperative and functional programming.

Table 2.

Year	Name	Language	Abstraction	Reference(s)
1996	Quantum Lambda Calculi	Lambda calculus	High	[89]
2000	λq	Lambda calculus	High	[11]
2004	QFC (QPL)	Flowchart	High	[131–133]
2005	QML	Similar to Haskell	High	[7]
2005	cQPL	Denotational	High	[87]
2013	QuaFL	Haskell	High	[82]
2013	Quipper	Haskell	High	[57, 58]
2013	Chisel-Q	Scala	High	[86]
2014	LIQUi\|>	F#	High	[152]
2015	Proto-Quipper	Haskell	High	[126]
2016	ProjectQ	Python	High	[60]
2016	qPCF	Lambda calculus	High	[109, 111]
2017	Quiskit	Python	High	[5]
2018	Strawberry Fields	Python	High	[78]
2018	Balckbird	Python	High	[78]
2018	Cirq	Python	High	[55]
2020	Silq	Python	High	[17]

Table 2. Quantum Functional Programming Languages

Most of the languages for functional quantum programming are based on Haskell or lambda calculus, although there are also proposals based on Python, which was not originally a functional language, but which was then expanded so as to include extensions that make it a multi-paradigm language and allow functional quantum extensions.

3.1.3 Other Quantum Programming Languages.

One object-oriented quantum programming language is FJQuantum [41], which is an extension of Featherweight Java, but with the added characteristic of managing quantum data and operations.

There are also some quantum circuit languages, such as QuECT (Quantum Embeddable Circuit Technique) [24], that allow one to embed circuit designs in a host programming language like Java. A similar example is QWIRE [114], which can define quantum circuits that are embedded in the Coq formal proof management system.

In addition to Q#, which is discussed in Section 4, there are other multiparadigm quantum programming languages: Strawberry Fields [78], a programming architecture for photonic quantum computing, built upon Python; or QuantumOptics.jl [80], an open system developed using Julia language and based on quantum optics.

Table 3 follows the same format as previous tables and presents information about other quantum programming languages, including circuit-based, declarative, and other types.

Table 3.

Year	Name	Language	Abstraction	Reference(s)
2004	CQP	Process calculus	High	[47–49]
2005	QPAlg	Process calculus	High	[72, 81]
2011	QuECT	Java	High	[24]
2017	Forest	Python	High	[136]
2017	QWIRE	Coq proof assistant	High	[114]

Table 3. Other Quantum Programming Languages

3.1.4 Quantum Programming Languages Landscape.

Figure 7 visually summarizes all the programming languages presented in this section according to the different dimensions studied. From this it can be observed that most of the proposals tend to raise the level of abstraction to make programming this new kind of computer progressively easier.

Fig. 7.

As we have seen throughout this section, the number of programming language proposals for the creation of quantum circuits and algorithms is quite large. These languages follow different paradigms, from those that simply describe a quantum circuit, to more academic languages that follow mathematical paradigms such as lambda calculus or process calculus, to languages similar to assembler (QASM), imperative languages, and functional and declarative languages. In addition, many of the proposals are extensions and libraries for general-purpose languages, among which Python stands out.

However, although the supply of quantum languages is high, most of them have not gone beyond the proposal stage and have not really been adopted in real conditions. The most widely accepted languages are those that have been proposed by the manufacturers of quantum computers (IBM, D'Wave, etc.), such as Qiskit, QASM, Cirq or Quatum LEAP or those that are being supported by generic quantum algorithm development platforms that are capable of deploying the algorithm on various computers. Among these last proposals we could find Microsoft's Q# or Python libraries such as Strawberry Fields or Pennylane (Xanadu).

3.2 Quantum Software Simulators and Design Environments

Due to the difficulty of building quantum computers and the limited access to the few real quantum computers currently available, a growing body of quantum simulators⁷ has emerged to assist in the tasks of designing and planning quantum algorithms and circuits. Quantum simulators have become a paramount concern due to the computation errors that still happen in quantum computers (cf. Section 3.4). Thus, when new quantum algorithms are being developed, it is advisable to conduct the initial proof-of-concept validation with a simulator. On the contrary, if a preliminary algorithm were to be executed in a real quantum computer and were it to fail, there would be no way to know if this was because of the algorithm design itself or was instead due to the fidelity of the quantum computer.

Most quantum simulators are mainly based on the management of arrays (due to the mathematics foundations of quantum computing) but a few of them are also based on graphs. In addition to LIQUi|>⁸ from Microsoft (discussed in Section 4), there are many different quantum simulators, the following list of which is based on, although not limited to, the list presented by [158]:

•

Amazon Braket⁹ is an AWS service providing access to quantum computing hardware as well as several quantum simulators.

•

Atom QASM Quantum Circuit Previewer¹⁰ is an Atom¹¹ editor package that converts QASM (Quantum Assembly) code into a graphical representation of the quantum circuit in real time and provides additional information on the circuit, such as depth, number of instructions, and state vector visualizations.

•

cuQuantum SDK¹² is a development platform for simulating quantum circuits on GPU-accelerated systems provided by Nvidia.

•

DDSIM [153] is part of the JKQ tools and provides a decision diagram-based quantum circuit simulator which allows one to simulate quantum circuits defined in a REAL or OpenQASM format, alongside parameterized Grover's and Shor's algorithms and QFT.

•

D'Wave¹³ provides a simulated environment in order to test locally the annealing algorithms.

•

Google Quantum AI Cirq¹⁴ is an open-source framework for programming quantum computers. Cirq provides a Python software library for writing, manipulating, and optimizing quantum circuits, and then running them on quantum computers and quantum simulators.

•

Intel-QS (Quantum Simulator) or QHIPSTER (The Quantum High Performance Software Testing Environment) [135] is a high-performance environment using parallel algorithms.

•

IBM Qiskit Simulators¹⁵ implements several simulation methods aimed at mimicking IBM's quantum computers.

•

Microsoft Q# Quantum Simulators¹⁶ provides different implementations of quantum primitives using Q# and dot.net as a platform.

•

PennyLane¹⁷ is designed to be hardware and device agnostic, allowing quantum functions to be easily dispatched to different quantum devices. A single computation can even include multiple quantum devices or simulators from different vendors.

•

ProjectQ [139] is an open-source simulator, started at the ETH Zurich, based on arrays, which can easily be extended by domain experts. The high-performance array-based simulator that it contains allows for the simulation of up to approximately 30 qubits on a desktop machine. It also contains an emulator which, by means of employing conventional shortcuts, is capable of determining, for instance, the results for Shor's algorithm faster than a simulator.

•

QCEC [21] is part of the JKQ toolset for quantum computing [153] which can be used for quantum circuit equivalence checking; it also has, as part of the toolset, some quantum mapping tools (QMAP).

•

QDENSITY/QCWAVE [142] is a Mathematica package for simulating a quantum computer.

•

Qibo [37] is an open-source software for fast evaluation of quantum circuits and adiabatic evolution which takes full advantage of hardware accelerators.

•

QuCirDET [122] is a design and simulation tool for quantum circuits.

•

Quirk¹⁸ is an open-source web-based simulator built upon JavaScript that can be executed inside the web browser. An example of this system can be seen in Figure 8.

•

Qulacs [140] is a fast simulator for quantum circuits intended for research purposes.

•

QuIDDPro [150] is a graph-based simulator, specialized only in the simulation of the Grover algorithm.

•

QuTe,¹⁹ is a Quantum Testbed which aims to provide a high-performance quantum computing simulation platform open to research teams worldwide.

•

QX [75] is a simulation platform based on arrays which parallelizes quantum gates for performance improvement.

Fig. 8.

As we can observe in the previous list, there is a plethora of options when dealing with quantum computer simulation. Nevertheless, most of the approaches are proofs of concept or have not enough community support in order to become a standard. In this way, the most useful and most used simulators are the ones provided by the main quantum computers manufacturers (like IBM or D'Wave) along with the creators of the main quantum development platforms like Microsoft, Pennylane, or Google. There are also other important alternatives such as those proposed by Amazon Braket or Microsoft Quantum Azure that provide quantum simulation platforms in their cloud services and the open-source online tool Quirk, made with Javascript, which can be run in the web browser and helps rapid prototyping of quantum circuits.

3.3 Quantum Software Optimizers

Figure 9 shows different topologies for various IBM's quantum computers. These serve to prevent certain combinations of quantum gates between the different qubits in the circuit which, although theoretically possible, are not available in the physical computer. For this reason, quantum optimizers are needed to adapt the theoretical quantum circuit to the actual quantum computer topology. In addition, through quantum optimization, reliability can also be improved, and the effects of quantum noise are reduced (cf. Section 3.4).

Fig. 9.

The main quantum optimizers, besides the IBM QX previously described, are [8]:

•

Feynman [9], a framework for the formal specification and verification of quantum circuits which is based on the Feynman path integral.

•

IonQ's tool [102], for handling continuous gate parameters and optimizing large-scale quantum circuits.

•

Newsynth/Gridsynth [127], which optimizes arbitrary single-qubit z-rotations by ancilla-free Clifford+T circuits.

•

pQCS [34], which uses a method for quantum circuit synthesis involving deterministic walks.

•

RevKit [137], an open-source C++ framework and library that implements a large set of reversible synthesis, optimizations, and mapping algorithms.

•

TOpt [22], with optimal algorithm decomposition into a sequence of many T gates interleaved with Clifford gates.

•

VOQC [62], which uses SQIR programs for proving the correctness of the optimizations and any other transformation performed.

Quantum software optimizers depend especially on the architecture of the quantum computer, so although there are some interesting initiatives that aim to optimize quantum algorithms, these proposals are limited in scope. Therefore, the best alternatives in this field are to be found in the manufacturers of quantum computers such as the IBM optimizer.

3.4 Quantum Tools and Libraries

Table 4, based on [52], shows the main quantum software tools and libraries that have been developed, including information about each one's type, distribution license, user interface, its use of

Table 4.

Name	Type	License	User interface	Q Gates	Other capabilities	Language	References
BackupBrain²¹	Both	Open source	GUI	Yes	Algorithms, Diagrams	Javascript
Bloch Sphere	Both	Open source	GUI, 3D, Drag & drop	Yes	Algorithms, Diagrams	Java	[66]
CHP	Library	Open source	Command-line	Yes	Algorithms	C	[1]
Cirq	Both	Open source	Command-line	Yes	All	Python	[107]
Drqubit²²	Toolkit	Open source, freeware	Command-line	Yes	Parallelism	MATLAB
Eqcs	Library	Open source	Command-line	Yes	None	C	[20]
Feynman	Both	Open source	GUI, Command-line	Yes	Algorithms, Parallelism	Maple	[124]
HOQST	Toolkit	Open source	Command-line	Yes	Diagrams	Julia	[25]
Jsquis	Both	Open source	Command-line	Yes	None	Javascript	[138]
LanQ	Library	Open source	Command-line	Yes	Algorithms, Parallelism	LanQ	[97]
libquantum	Library	Open source	Command-line	Yes	Algorithms, Parallelism	C, C++	[31, 53]
Linerar AI²³	Library	Freeware	GUI, Command-line	Yes	Algorithms, Diagrams	Mathematica
M-fun	Library	Open source	GUI, Command-line	Yes	None	MATLAB/ Octave	[146]
Mukai²⁴	Library	Commercial	Command-line	No	Accelerators, Diagrams	Python
Open Qubit	Library	Open source	Command-line	Yes	Algorithms	C++	[130]
OpenQASM	Both	Open source	Command-line	Yes	Diagrams	QASM	[28, 29, 93]
OpenQUACS	Both	Open source	GUI, Command-line	Yes	Algorithms, Parallelism	Maple	[92]
ProjectQ	Both	Open source	Command-line	Yes	All	Python	[139]
Q-gol	Both	Open source	GUI, 3D, Drag & drop	Yes	Algorithms	CaML	[23]
Q-Kit	Toolkit	Freeware	GUI, Drag & drop	Yes	All		[143]
Q++²⁵	Library	Open source	Command-line	Yes	Algorithms, Diagrams	C++
QCAD	Toolkit	Freeware	GUI, 3D, Drag & drop	Yes	Diagrams		[104]
QCGPU	Both	Open source	Command-line	Yes	Parallelism	Rust & OpenCL	[74]
Qchas²⁶	Library	Open source	Command-line	Yes	Diagrams	Haskell
QCircuits	Both	Open source	Command-line	Yes	All	Python	[155]
QDENSITY	Both	Open source	GUI, Command-line	Yes	Diagrams	Mathematica	[73]
Qi²⁷	Both	Open source	Command-line	Yes	None	Mathematica
Qinf	Both	Open source	None	Yes	Diagrams	Maxima	[99]
QIO	Library	Open source	Command-line	Yes	Diagrams	Qio + Haskell	[6]
Qiskit	Both	Open source	GUI, Command-line	Yes	All	Python	[27]
QMDD	Library	Open source	Command-line	No	Diagrams	C++	[95]
QOCS²⁸	Both	Open source	Command-line	Yes	Algorithms	OCaML
Qrack	Both	Open source	Command-line	No	None	C++	[101]
Qsims	Both	Open source, commercial	Command-line	Yes	Algorithms, Parallelism	C++	[15]
QSWalk.jl²⁹	Both	Open source	GUI, Command-line	Yes	None	Julia
QUA³⁰	Toolkit	Commercial	Command-line	No	Optimization	QUA
Quantavo	Both	Open source	Command-line	Yes	Algorithms, Parallelism	Maple	[40]
Quantencomputer	Both	None	Command-line	Yes	Algorithms	MATLAB	[144]
Quantum³¹	Both	Freeware	GUI, Command-line	Yes	All	Mathematica
Quantum Circuit	Both	Open source	Command-line	Yes	Algorithms, Diagrams	Javascript	[150]
Quantum Fog	Both	Open source	GUI, Drag & drop	Yes	All		[32]
Quantum Programming Studio	Toolkit	Open source	Drag & drop	Yes	Algorithms, Parallelism, Diagrams	Javascript	[69]
Quantum User Interface³²	Toolkit	Open source	GUI, Drag & drop	Yes	None	Protobuf
Quantum.NET³³	Both	Open source	Command-line	Yes	None	NET
Quantum++	Both	Open source	Command-line	No	None	C++	[51]
QuantumOptics. jl	Both	Open source	GUI, 3D, Command-line	No	Algorithms, Diagrams	Julia	[80]
QuantumUtils	Both	Open source	Command-line	Yes	Parallelism, Diagrams	Mathematica	[63]
QuantumWalk. jl³⁴	Both	Open source	GUI, Command-line	Yes	Algorithms	Julia
Qubit Workbench³⁵	Toolkit	Commercial	GUI, Drag & drop	Yes	Algorithms, Diagrams
Qubit Workbench³⁶	Toolkit	Freeware	GUI, Drag & drop	Yes	None
Qubit4Matlab	Library	Open source	Command-line	Yes	All	MATLAB	[147]
QuEST	Both	Open source	Command-line	Yes	None	C	[71]
QuIDE	Toolkit	Open source	GUI, Drag & drop	Yes	All	.NET	[112]
QX Simulator³⁷	Both	Open source	Command-line	No	Parallelism	Quantum Code
Scaffold/ScaffCC	Both	Open source	Command-line	No	Algorithms	Scaffold	[70]
SimQubit	Both	Open source	GUI, Drag & drop	Yes	Algorithms, Diagrams	C++	[113]
Staq	Both	Open source	Command-line	Yes	None	C	[10]
Tequila	Library	Open source	Command-line	Yes	None	Python	[79]

Table 4. Quantum Software Tools and Technologies

quantum gates, its simulation and other capabilities, the programming language it relies on, plus some references.

As for the existing libraries oriented to support the creation of quantum algorithms, we can observe that they are available for the currently most used general purpose programming languages such as C, C++, Java, JavaScript, Python, Julia, or MATLAB, however, we can observe a special preference for adapting the libraries to Python, which has become the de facto standard in the encapsulation of quantum algorithms within classical systems that invoke them.

3.5 Full Stack Software of Main Quantum Computing Vendors

In this section we present the principal full stack platforms used in the quantum software sold by the main vendors (see Figure 10) and summarize the most important characteristics of each stack. In [83] we can find a comparison between the last three of these.

Fig. 10.

•

D-Wave³⁸ is a Canadian firm offering an adiabatic quantum computer, specialized in the performance of optimization problems and various machine learning tasks. Its machine language is called “QMASM”, above which is the open source qbsolv library, which can solve optimization problems by decompiling QUBO problems (Quadartic UNconstrained Binary Optimization).

•

Google³⁹ has its own quantum platform, called “Quantum AI”, for working with quantum circuits on near-term quantum computers. This platform is based on Circ, which is a Python library “for writing, manipulating and optimizing quantum circuits and running them against quantum computers and simulators” [83]. On top of this quantum Python library other libraries can be run, such as OpenFermion (which focuses on simulating fermionic systems, including quantum chemistry) and TensorFlow Quantum (for hybrid quantum-classical machine learning).

•

Honeywell,⁴⁰ a U.S. company based in Charlotte, North Carolina, centers its efforts on providing quantum computing based on Trapped-ion technology. Honeywell's quantum computers do not yet have open access, but the idea behind their development is that these computers will in the future be compatible with quantum algorithms that can run on other companies’ computers.

•

IBM⁴¹ provides several quantum computers on a cloud-based service. These are programmed through quantum circuits using a web quantum composer or by defining them in Open QASM language. These circuits are supplied to the quantum computer through the QISkit Terra library as a platform provider. On top of these circuits, we can find several libraries focused on specific domains such as QISKit Aqua for quantum application.

•

Rigetti⁴² is an American company, based in California, which provides access to its quantum processors via its new ASPEN-8 processors. Their software stack is composed of several software components, such as the PyQuil programming language (provided as a Python library) and Quilc, an optimizing compiler for gate-based quantum programs. They also have a Quantum Virtual Machine as an open-source implementation of a quantum computation simulator.

•

Xanadu⁴³ bases its quantum computing on photonic technology, which provides scalability, robustness, and the practicality of being able to operate at room temperature. Its devices are accessed through the Xanadu quantum cloud and feature the Strawberry Fields programming language provided as a Python library. On top of this stack, various libraries such as TensorFlow can be used to carry out domain-oriented applications. In addition, Xanadu provides a Python library called “Penny Lane” that aims to program a quantum computer in the same way as a neural network is trained. This Penny Lane library can also be used on other quantum platforms such as IBM, Google, or Rigetti.

As can be seen, there are many different proposals and technologies aimed at a quantum computer with ample computational power. Most of the proposals offer access to quantum computers in the cloud, although most of them must be used through proprietary libraries or languages. Several of them already support as part of the upper layers of the quantum software stack the use of other libraries and tools such as TensorFlow that are oriented to the realization of real applications, particularly those which are based on machine learning.

However, most of the quantum computing vendor full stack software are conceived for a specific underlying hardware, so that each manufacturer brings its own solutions, architectures, and specific hardware–software dependencies [65].

3.6 Quantum Software Development and Run Platforms

Besides the full stack environments that we mentioned in the previous section, there are also some suites, listed below, that can design and run quantum applications and workflows in a unique environment. These platforms normally interact with different quantum computers, quantum simulators, and tools:

•

1QBit⁴⁴ provides a hardware-agnostic platform and several services to solve intractable industry problems. These services include 1Qloud which is a powerful optimization platform enabled by classical and quantum computers.

•

Aliro⁴⁵ is a quantum platform mainly oriented to the creation and optimization of quantum networks and Quantum-secure communications, providing its services as Entanglement as a Service (EaaS) so that it can be used by applications.

•

Braket⁴⁶ is the proposal from Amazon with which the US company aims to facilitate quantum computing and give access to different quantum computers and simulators hosted on the AWS platform. It provides an SDK that can create quantum algorithms and can run them on any compatible quantum hardware (such as D-Wave, IONQ, or Rigetti) provided through the Amazon Braket service, and it can also be employed using hybrid approaches such as Penny Lane or with Jupyter notepads. It also has a repository with pre-designed algorithms and tutorials and provides a machine and user administration environment. Although Braket does not specifically support hybrid software, it does offer a Platform as a Service (PaaS) that makes integration with classical software easier.

•

Classiq Technologies⁴⁷ is a platform for the design of quantum algorithms through automation and synthesis technologies. This platform aims to create such quantum algorithms from ideas without the need for coding at the quantum gate level; for this task, they provide a programming environment that organizes the entire quantum software stack and creates algorithms compatible with the main quantum programming environments (such as Qiskit, Cirq, or Q-sharp) and which are portable to the different types of quantum hardware.

•

isQ-Core⁴⁸ is a new quantum computing programming software developed by the Chinese Academy of Sciences in 2022. There is not much information about it on the literature yet, but it is claimed to be an important step in the combination of domestic quantum computing software and hardware.

•

Orquestra from Zapata⁴⁹ is a quantum programming environment based on the construction of quantum workflows. These facilitate working at the right level of abstraction but nonetheless allow the programmer to get close to the hardware when necessary. It allows deployment, scaling, and parallelization of workflows by submitting them to Orquesta Quantum Engine servers via REST API, enabling their execution on classical and quantum devices, including quantum gate-based computers, quantum annealers, and classical quantum-inspired devices. Among the devices supported by this platform are IBM, Rigetti, IonQ, and Honeywell. Therefore, Orquestra supports the execution of hybrid software.

•

QPath⁵⁰ is a quantum software development and lifecycle application platform which implements a complete lifecycle pipeline to create professional quantum software solutions [64]. QPath makes it easy to use different quantum programming languages and platforms for coding new quantum algorithms, using a Quantum Software Engineering approach. It provides several connections to the main quantum platforms, so it is possible to run the quantum algorithms in quantum computers such as IBM, Rigetti, or D-Wave, among others. Thus, QPath can also be used to integrate classical and quantum software and can be used to build hybrid systems.

•

Strangeworks QC⁵¹ is a platform designed to serve as the central hub for all quantum hardware and software vendors, enterprises, academia, and other entities. Its aim is to facilitate the application of quantum computing to a wide range of problems and research. Its user interface requires no installation or configuration and supports all major quantum frameworks, as well as collaboration and code sharing.

•

t|ket⟩ from CQC (Cambridge Quantum Computing)⁵² is an architecture-agnostic quantum software stack with its own compiler. It can translate machine-independent algorithms into executable circuits, optimizing them for physical qubit layout while at the same time reducing the number of operations that is required. On top of its basic quantum layer, several libraries can be executed, including ones that are related to chemistry, machine learning, finance, and cybersecurity.

Most of these software integrated development environments are more intended for experiment and executing independent quantum algorithms/circuits than a real business development environment [65]. In fact, they neither support complete rigorous quantum software lifecycle [117], nor quality quantum software development [149]. Two other very difficult challenges for this kind of environment are to work with both gate-based and annealing approaches, and to facilitate the development of integrated quantum/classical hybrid software in a dynamic way [118].

3.7 Quantum Software Error Correction Tools

QEC is an essential aspect in current NISQ (Noisy Intermediate Scale Quantum) computers. QEC can be accomplished at firmware level, but also at software level. Some of the tools available in this category are Devkit, Black Opal, or Boulder Opal [13].

Commercial full platforms provide their own QEC tools as well as methods like Microsoft error correction libraries⁵³ and other internal proprietary methods in quantum computing platforms such as IBM or D-Wave.

When developing quantum software (as high level as we can), quantum error and possible error correction tools are usually not taken into account, delegating this task to proprietary tools implemented in the firmware of quantum platforms.

4 Quality Assessment of Quantum Software Platforms

This section first introduces a quality model to assess quantum software platforms, which is based on existing reference model for classical software plus other specific quality characteristics (cf. Section 4.1). Then, the quality model is preliminarily applied to assess main quantum software platforms (cf. Section 4.2).

4.1 Quantum Quality Criteria

In “The Talavera Manifesto” [119], we define some principles for Quantum Software Engineering and Programming, most of which can be used for a quantum software platform in accordance with the following quality requirements:

•

R1. It must be agnostic regarding quantum programming languages and technologies.

•

R2. It must embrace the coexistence of classical and quantum computing.

•

R3. It must support the management of quantum software development projects.

•

R4. It must consider the evolution of quantum software.

•

R5. It must aim at delivering quantum programs, if at all possible, with zero defects.

•

R6. It must assure the quality of quantum software.

•

R7. It must promote quantum software reuse.

•

R8. It must cover the governance and management of software.

The ISO/IEC 25010 standard [68] can be also used as a reference model to frame specific quality requirements for quantum software platforms. Some of the quality characteristics should be the same as those that apply in the “classical” integrated development environments, i.e., functional suitability, usability, security, maintainability, or portability, among others. However, three such characteristics should be regarded as particularly crucial:

•

Compatibility. It is very important that the platform offers interoperability between the different quantum computers, quantum programming languages, etc. (see R9).

•

Performance efficiency, mainly resource utilization and capacity. This could be accomplished by a scalable architecture, with optimizers of quantum circuits and programs (see R10).

•

Reliability. High error rates in quantum computation are due to a combination of factors including decoherence, dephasing of the qubit states, calibration errors, and readout and gate infidelities. Hence, the platform should include QEC tools and other mechanisms to improve reliability (see R11).

4.2 Evaluation of Integrated Quantum Software Platforms

It is very difficult to conduct an accurate and fair evaluation of the different quantum software platforms because they are continuously changing and adding new features and, in some cases, they are still at a beta stage.

However, we think that it can be useful at least to characterize the platforms according to the requirements mentioned above. To this end we will evaluate the requirements as follows: a tick means that the platform fulfills the requirement, and no tick means either that we consider that it does not fully deal with the corresponding requirement or that we do not have enough information to reach a decision about a certain requirement.

As Tables 5 and 6 show, there exist several approaches for quantum computing, and their number is increasing every day. Although most of the stacks and platforms are designed to facilitate algorithm creation, some of the desirable characteristics for quantum algorithms are missing in the majority of the environments.

Table 5.

Requirement	D-Wave	Google	Honeywell	IBM	Microsoft	Rigetti	Xanadu
R1-agnostic					✓
R2-coexistence	✓	✓	✓	✓	✓	✓	✓
R3-project management					✓
R4-evolution
R5-zero defects
R6-quality
R7-reuse	✓	✓			✓	✓	✓
R8-software governance
R9-compatibility					✓
R10-efficiency	✓	✓	✓	✓	✓	✓	✓
R11-reliability	✓	✓	✓	✓	✓	✓	✓

Table 5. Quantum Stacks Review (Full Stacks)

Table 6.

Requirement	1QBit	Aliro	Amazon Braket	Classiq Technologies	Zapata Orchestra	Qpath	Srangeworks	T\|ket>
R1-agnostic	✓		✓	✓	✓	✓	✓	✓
R2-coexistence	✓	✓	✓		✓	✓	✓
R3-project management			✓	✓	✓	✓	✓
R4-evolution						✓
R5-zero defects						✓
R6-quality						✓
R7-reuse	✓		✓	✓	✓	✓	✓
R8-software governance
R9-compatibility	✓		✓	✓	✓	✓	✓	✓
R10-efficiency	✓	✓	✓		✓	✓	✓	✓
R11-reliability	✓	✓	✓	✓	✓	✓	✓	✓

Table 6. Quantum Stacks Review (Integrated Platforms)

Some interesting project management features (see R3 in Table 6) are absent from almost every system, and quantum software governance is ignored in all of them. Despite the increasing number of quantum systems and software platforms and their rapid evolution, a lot of work is still needed to achieve adequate quality levels in quantum software platforms.

5 Main Implications for Researchers and Practitioners

This section provides some recommendations for researchers and practitioners by means of some general guidelines explaining how to benefit from this review depending on their current work. First, Section 5.1 is oriented for researchers, while Section 5.2 is devoted for explaining practitioners’ expectations.

5.1 Open Issues for Researchers

This paper presented a review about quantum software platforms contextualized in its main, critical components, ranging from programming languages to simulators, optimizers, tools or libraries, among others. The results of this review suggest that quantum software technology ‘is still in its infancy’ [103], hence a big-bang approach has emerged in the last years with a vast variety of programming languages and development platforms. This means that probably further languages and tools will appear in a near future.

In this context, the main recommendation for researchers is that they should be eager to update results of this review in the coming years. In this sense, the following points highlight some key research directions for every software component discussed in Section 3.

•

Programming languages. As stated in Section 3.1, the trend in the most recent programming languages is the addition of more and more abstractions. The lack of higher abstraction mechanisms was in fact the problem of the first languages. Additionally, some control structures and operations that are very common in most of the classical programming languages will probably be incorporated. This is due to the fact that most of the current quantum programming languages still have deficiencies in comparison with classical ones [14], for example (i) lack of control structures that can manage traditional control in addition to the non-deterministic and probabilistic ones; (ii) a deficient derivation of quantum programs in a compositional manner; and (iii) the absence of formulation of interfaces and signatures based on parameters to be computed dynamically.

•

Simulators and design environments. Various simulators already exist for comprehending quantum computing fundamentals and help to develop quantum algorithms. However, the next abstraction level is needed with regards to design environments that are more focused on software design than on quantum circuits. We refer to the high-level design of whole hybrid software systems including some existing modelling languages like UML [116], or other domain specific languages.

•

Optimizers. This point is key for success of quantum computing, especially in a moment when quantum computers are scaled in number of qubits. However, it is not a core area of quantum software engineering since it is more a task of co-design [145] of quantum hardware and the firmware needed for optimizing programs for the specific topology and other constraints.

•

Tools and libraries. There exist plenty of tools and libraries that have been proposed, some of them integrated in the full-stack landscapes for main quantum software vendors. Libraries covering domains that come up with built-in solutions for well-known problems in specific sectors is a field of research to be developed. Also, the creation and integration of libraries achieving a good level of usability and portability is a pending research topic.

•

Software development and run platforms. In a similar way to the need for high-level design tools, integrated development environments (IDEs) for designing, coding, and running quantum programs need to be improved. The future IDEs must tend to add the common features that existing IDEs for classical software already have, e.g., supporting different quantum programming languages and being technology-agnostic. Another research challenge is building “BizDevOps” quantum environments and facilitating continuous engineering from business needs, through the development of quantum solutions, to their deployment and operation [118].

•

Error correction tools. Error correction is a field with intensive research efforts, since it is key to maximize the whole potential of quantum computers, and consequently the software applications that runs on those devices.

5.2 Benefits of this Review for Practitioners

This section presents the main implications and some recommendations for different practitioners: fully newbie people, profiles coming from the quantum computing & engineering fields who want to learn about how to develop quantum software in a better way, other professionals coming from the traditional software engineering field who want to learn about quantum computing technology and programming, as well as decision-makers or managers.

•

Newbie. Inexperienced newcomers to quantum computing can consider this review as a landscape of the quantum software technology. It is specifically important to become familiar with quantum simulators and design environments (cf. Section 3.2) to get a better understanding of quantum foundations. Then, some of the quantum software development and run platforms (cf. Section 3.6) could be used to play with some of the running examples that are already available in such environments for which there is no need for in-depth knowledge.

•

Physicists and mathematicians. These professionals that work in the quantum computing field usually design new quantum algorithms in theoretical basis. In this point, some of the simulators and design environments (cf. Section 3.2) could be useful for this task. Sometimes they also implement those algorithms in an ad hoc way in scientific environments (some of them depicted in this review). However, other programming languages mentioned in this review (cf. Section 3.1) which operates at higher abstraction level could be useful for these practitioners.

•

Quantum programmers. This kind of professional is a subset with people coming from previous roles but also from the software engineering field. For this kind of professional, the tools and libraries presented in Section 3.4 are useful since those can be used as libraries with many quantum software solutions ready to be integrated in more complex, larger systems. Also, they should consider the quantum software development and run platforms (cf. Section 3.6) since it could provide some hints on how to boost the quantum programming task. Checking the programming languages review in Section 3.1 might be valuable as well.

•

Software engineers. Experienced software engineers who must cope with quantum software for the first time could primarily benefit from simulators and design environments (cf. Section 3.2), which can help them to learn about quantum software foundations. After that, they should check the review about quantum programming languages (cf. Section 3.1) in order to assess the most appropriate one for a certain project. Other important sections from which these practitioners can benefit is the review of the different full-stack technology landscapes of the amin vendors as well as software development and run platforms (cf. Sections 3.5 and 3.6). These parts offer some ideas on how to improve the production of quantum software by applying best practices of software engineering. For example, how to develop quantum software in a technological agnostic way and orchestrate the execution of quantum programs in different devices; how to measure, control, and assure quantum circuits quality [30]; or how to test quantum programs [44], among other interesting open issues.

•

Decision-makers/Managers. In the current state of the art concerning quantum software technology, the decision-making process is risky. In every project of quantum software development, many variables have to be decided (the programming language, the development environment, the target quantum devices, etc.). This entire review can help managers to make such decisions, in which the main risk is the future deprecation or the rise of new, different alternatives. Other important aspects to be considered by this profile is the set of existing software libraries (cf. Section 3.4) specifically developed for some business sectors, which could help to solve specific enterprise problems.

6 Conclusions

We are witnessing in quantum computing what is undoubtedly a revolution in information technology. This revolution is comparable to the industrial revolution of the 19th century, which led to the birth of the machine age, or to the changes that took place in the 20th century's information age. Today, quantum computers are a reality and are forecast to be exponentially more powerful than even the classical supercomputers. Experts reiterate that the 21st century will be “the quantum era”.

To take full advantage of this enormous computing potential that can enable us to solve real problems that are intractable when addressed by classical computers, it is of fundamental importance to have good and reliable software platforms. The transition of the proof-of-concept devices to become useful computational systems is beset by a range of new technical challenges, from improving and expanding qubit hardware to developing control/operating systems, to innovations in algorithms and applications. The success or otherwise in pursuing the solutions to these technical challenges will define the demand for the new generation of hardware, software, and application engineers needed to create and sustain the nascent quantum computing industry [88]. There are major opportunities in store for most business sectors, with many promising applications to be delivered in the future.

Lately, we have observed an explosion of different quantum programming languages, either as new stand-alone languages or as libraries to support traditional languages such as Python. But it is not enough to create the most suitable programming languages for this task if we do not also have the necessary environments and platforms to help in the construction of quantum algorithms for these new applications. We hope that the proposed functional and non-functional requirements listed above could serve as a guide for quantum software technology vendors when they are constructing new frameworks and platforms (or developing existing ones). The main implication of this research for practitioners, we believe, is that software developers need to support the production and operation of quantum software in an industrial and controlled way.

In this research we have conducted an extensive review of the principal quantum languages, libraries, platforms, and tools and found that most of them lack important characteristics such as quantum project support, quantum software governance, or a due focus on quantum software quality or quantum software evolution.

We are convinced that quantum software engineering presents us with an essential and highly motivating challenge, since quantum computing will allow us to unlock the key to a unique opportunity, in the same way as the pioneers of software engineering experienced with their groundbreaking work in the 1960’s. To do so, it is essential that classical and quantum software engineers revise methods, techniques, and practices, and, most of all, that they incorporate the guiding principles of Quantum Software Engineering to an appropriate degree [119].