Quantum Software Engineering (QSE) is emerging as a critical discipline to make quantum computing accessible to a broader developer community; however, most quantum development environments still require developers to engage with low-level details across the software stack—including problem encoding, circuit construction, algorithm configuration, hardware selection, and result interpretation—making them difficult for classical software engineers to use. To bridge this gap, we present C2 \(\lvert Q \rangle\) , a hardware-agnostic quantum software development framework that translates specific types of classical specifications into quantum-executable programs while preserving methodological rigor. The framework applies modular software engineering principles by classifying the workflow into three core modules: an encoder that classifies problems, produces Quantum-Compatible Formats (QCFs), and constructs quantum circuits, a deployment module that generates circuits and recommends hardware based on fidelity, runtime, and cost, and a decoder that interprets quantum outputs into classical solutions. This architecture supports systematic evaluation across simulators and Noisy Intermediate-Scale Quantum (NISQ) quantum devices, remaining scalable to new problem classes and algorithms. In evaluation, the encoder module achieved a 93.8% completion rate, the hardware recommendation module consistently selected the appropriate quantum devices for workloads scaling up to 56 qubits. End-to-end experiments on 434 Python programs and 100 JSON problem instances demonstrate that the full C2 \(\lvert Q \rangle\) workflow executes reliably on simulators and can be deployed successfully on representative real quantum hardware, with empirical runs limited to small- and medium-sized instances consistent with current NISQ capabilities. A proxy-based usability analysis further indicates substantial reductions in handwritten lines of code and explicit configuration steps compared to conventional quantum SDK workflows. These results indicate that C2 \(\lvert Q \rangle\) lowers the entry barrier to quantum software development by providing a reproducible, extensible toolchain that connects classical specifications to quantum execution. The open-source implementation of C2 \(\lvert Q \rangle\) is available at https://github.com/C2-Q/C2Q and as a ready-to-use Python package at https://pypi.org/project/c2q-framework/ .
Quantum Software Engineering (QSE) is emerging as a critical discipline to make quantum computing accessible to a broader developer community; however, most quantum development environments still require developers to engage with low-level details across the software stack—including problem encoding, circuit construction, algorithm configuration, hardware selection, and result interpretation—making them difficult for classical software engineers to use. To bridge this gap, we present C2 (\lvert Q \rangle) , a hardware-agnostic quantum software development framework that translates specific types of classical specifications into quantum-executable programs while preserving methodological rigor. The framework applies modular software engineering principles by classifying the workflow into three core modules: an encoder that classifies problems, produces Quantum-Compatible Formats (QCFs), and constructs quantum circuits, a deployment module that generates circuits and recommends hardware based on fidelity, runtime, and cost, and a decoder that interprets quantum outputs into classical solutions. This architecture supports systematic evaluation across simulators and Noisy Intermediate-Scale Quantum (NISQ) quantum devices, remaining scalable to new problem classes and algorithms. In evaluation, the encoder module achieved a 93.8% completion rate, the hardware recommendation module consistently selected the appropriate quantum devices for workloads scaling up to 56 qubits. End-to-end experiments on 434 Python programs and 100 JSON problem instances demonstrate that the full C2 (\lvert Q \rangle) workflow executes reliably on simulators and can be deployed successfully on representative real quantum hardware, with empirical runs limited to small- and medium-sized instances consistent with current NISQ capabilities. A proxy-based usability analysis further indicates substantial reductions in handwritten lines of code and explicit configuration steps compared to conventional quantum SDK workflows. These results indicate that C2 (\lvert Q \rangle) lowers the entry barrier to quantum software development by providing a reproducible, extensible toolchain that connects classical specifications to quantum execution. The open-source implementation of C2 (\lvert Q \rangle) is available at https://github.com/C2-Q/C2Q and as a ready-to-use Python package at https://pypi.org/project/c2q-framework/ .
Quantum computing is quickly becoming a potentially disruptive technology that can tackle the problems inaccessible to classical computers, but the use of quantum computing in real software systems has yet to be fully explored. Present day quantum studies are largely focused on the development of algorithms and hardware, whereas engineering workflows to be used to enable smooth hybrid quantum-classical operations attract limited attention. The paper suggests a concept of quantum-ready software engineering- a systematic approach to applying established principles of software engineering to hybrid systems. In order to meet maintainability, scalability, and reliability objectives in hybrid applications, propose the adoption of a multilayered design, such as abstraction, integration, orchestration, and verification. An example concrete programming template, written in Python in Qiskit, demonstrates how quantum functions being used as modular services can be simulated with classical software. Evaluation measures (maintainability index, latency, and modularity) demonstrate the feasibility of the framework. Results indicate that the hybrid pipelines can be designed in a systematic way using quantum-classical-adapted design patterns. The study introduces a repeatable methodology, program templates, and design pattern engineering principles, which open the door to additional development of quantum DevOps and design pattern formalization. This project, by bridging the gap between classical software engineering and quantum integration, gives a platform upon which to build extraordinarily reliable, scalable systems in the Noisy Intermediate-Scale Quantum and beyond.
Reproducibility and comparability remain fundamental challenges in the empirical evaluation of Quantum Software Engineering (QSE) tools. These challenges arise from the intrinsic probabilistic behavior of quantum programs and the variability introduced by quantum hardware and simulator backends. While existing quantum benchmarks typically offer only static circuit definitions, they often leave researchers responsible for data generation and execution, hindering the creation of standardized and reproducible experiments. In this paper, we introduce QSimBench, a novel, open-source benchmark suite and accompanying Python library designed to address these limitations. QSimBench provides over 20 million precomputed shot-level execution traces:20,000measurements each, across14quantum algorithms, multiple circuit sizes (4−15qubits), and six Qiskit-based backends including both ideal and noise-injected simulations. Each configuration includes not only detailed measurement histories but also the original circuit in OpenQASM, the backend's noise model, and configuration metadata, ensuring full transparency and enabling in-depth analysis. QSimBench empowers researchers to conduct scalable, reproducible, and statistically rigorous evaluations of QSE tools, such as those for monitoring, orchestration, and statistical post-processing, without the need for expensive or difficult-to-reproduce quantum executions. The benchmark is distributed with a lightweight Python API that facilitates fast data retrieval, flexible sampling strategies, and seamless integration into experimental pipelines. QSimBench is publicly available, aiming to foster collaborative and reproducible research within the quantum software community.
Quantum computing promises transformative computational capabilities; however, the absence of structured and standardized software engineering significantly limits its practical scalability. Quantum Software Engineering (QSE) remains fragmented, tool-centric, and largely experimental. This paper proposes a structured Quantum Software Engineering Lifecycle Framework that systematically integrates requirements engineering, hybrid design, quantum development, verification, deployment, and governance. To validate the proposed lifecycle, a two-stage evaluation was conducted. First, a Delphi-based expert validation involving 15 domain experts assessed clarity, feasibility, scalability, and hybrid applicability. Second, a simulation-based comparative analysis using Qiskit and PennyLane evaluated the lifecycle against ad-hoc development workflows across variational and search-based quantum algorithms. Results demonstrate a 24% reduction in development time, 15–18% improvement in execution fidelity, and significant gains in modularity, reusability, and tool interoperability. These findings confirm that adopting a structured lifecycle enables more reliable, scalable, and sustainable quantum software development, positioning QSE as a mature engineering discipline rather than purely experimental practice.
Quantum computing is one of the research areas progressing rapidly toward practical deployment, yet the engineering of scalable and reliable quantum software remains underdeveloped. Current quantum software engineering (QSE) practices are largely tools‐driven and ad hoc that providing limited support for managing probabilistic execution, hybrid quantum–classical workflows, noise sensitivity, and hardware constraints. This study proposed a structured QSE lifecycle that integrates quantum‐specific characteristics with disciplined software engineering practices and principles. The proposed lifecycle organizes development into six phases, encompassing quantum requirements engineering, formal modeling, architecture and circuit design, hybrid integration, noise‐aware testing, and deployment with monitoring. Each phase is supported by explicit artifacts and quantitative criteria to enable systematic progression and iterative refinement. The QSE is validated through expert assessment and simulation‐based experimentation using representative variational quantum algorithms under the realistic noise conditions. The results show improved fidelity convergence, reduced resource overhead, enhanced development stability (DS), and more reliable validation compared with unstructured workflows, demonstrating the value of lifecycle‐driven engineering for quantum software systems.
Commercially available Noisy Intermediate-Scale Quantum (NISQ) devices now make small hybrid quantum-classical experiments practical, but many tools hide configuration or demand ad-hoc scripting.
We introduce the Quantum Experiment Framework (QEF): A lightweight framework designed to support the systematic, hypothesis-driven study of quantum algorithms. Unlike many existing approaches, QEF emphasises iterative, exploratory analysis of evolving experimental strategies rather than exhaustive empirical evaluation of fixed algorithms using predefined quality metrics. The framework's design is informed by a comprehensive review of the literature, identifying principal parameters and measurement practices currently reported in the field.
QEF captures all key aspects of quantum software and algorithm experiments through a concise specification that expands into a Cartesian product of variants for controlled large-scale parameter sweeps. This design enables rigorous and systematic evaluation, as well as precise reproducibility. Large sweeps are automatically partitioned into asynchronous jobs across simulators or cloud hardware, and ascertain full hyper-parameter traceability. QEF supports parameter reuse to improve overall experiment runtimes, and collects all metrics and metadata into a form that can be conveniently explored with standard statistical and visualisation software.
By combining reproducibility and scalability while avoiding the complexities of full workflow engines, QEF seeks to lower the practical barriers to empirical research on quantum algorithms, whether these are designed for current NISQ devices or future error-corrected quantum systems.
This paper introduces a vision for Quantum Software Development lifecycle, proposing a hybrid full-stack iterative model that integrates quantum and classical computing. Addressing the current challenges in Quantum Computing (QC) such as the need for integrating diverse programming languages and managing the complexities of quantum-classical systems, this model is rooted in the principles of DevOps and continuous software engineering. It presents a comprehensive lifecycle for quantum software development, encompassing quantum-agnostic coding, testing, deployment, cloud computing services, orchestration, translation, execution, and interpretation phases. Each phase is designed to accommodate the unique demands of QC, enabling traditional software developers to engage with QC environments without needing in-depth QC expertise. The paper presents a detailed implementation roadmap, utilizing a range of existing tools and frameworks, thereby making quantum software development more accessible and efficient. The proposed model not only addresses current challenges in quantum software development but also makes a substantial contribution to the field of Quantum Software Engineering (QSE). By proposing a structured and accessible model, it sets the stage for further advancements and research in QSE, enhancing its practicality and relevance in a wide range of applications.