AllLabsIn progressQuantum Red theme

QuantumLab

QuantumLab explores quantum circuits through a C++/Qt desktop interface. The existing source implements state-vector operations, gate composition, measurement logic and OpenQASM-related tooling. The project direction extends the circuit designer with interactive visualisation, state transitions, Bloch-sphere exploration, experiments and optional quantum-language integrations.

C++Qt 6QMLOpenQASM
QUQuantumLab
C++Main technology
28Tracked files*
11.cpp files
10.h files
01 · What it does

What the application does

Capabilities evidenced by project documentation and source structure; some behaviours require platform configuration.

01

Qubit-wire circuit editor with H, X, Y, Z, S, T and

Qubit-wire circuit editor with H, X, Y, Z, S, T and controlled gates. This capability is documented in the project material; the detail page distinguishes its intended user experience from the supporting implementation and any configuration needed to run it.

02

Complex state-vector simulation with measurement rec

Complex state-vector simulation with measurement records. This capability is documented in the project material; the detail page distinguishes its intended user experience from the supporting implementation and any configuration needed to run it.

03

Circuit serialisation and OpenQASM import/export com

Circuit serialisation and OpenQASM import/export components. This capability is documented in the project material; the detail page distinguishes its intended user experience from the supporting implementation and any configuration needed to run it.

04

Calculation history and individual operation steps.

Calculation history and individual operation steps. This capability is documented in the project material; the detail page distinguishes its intended user experience from the supporting implementation and any configuration needed to run it.

05

Planned Bloch-sphere, 3D charts, Q# and advanced sim

Planned Bloch-sphere, 3D charts, Q# and advanced simulators. This capability is documented in the project material; the detail page distinguishes its intended user experience from the supporting implementation and any configuration needed to run it.

02 · Technical structure

How the system works

Technical architecture drawn from the repository and supplied documentation.

01

QuantumCircuit describes ordered gate operations on qubits.

02

StateVectorSimulator computes complex-amplitude evolution and records frames.

03

MeasurementEngine samples state probabilities; OpenQASM components support circuit exchange.

04

Qt Quick/QML supplies the circuit editing interface.

01 · Input or user action

The workflow starts with the corresponding user choice or data entry. Qubit-wire circuit editor with H, X, Y, Z, S, T and controlled gates. This capability is documented in the project material; the detail page distinguishes its intended user experience from the supporting implementation and any configuration needed to run it.

02 · Application processing

The relevant component must interpret the input, apply the project rules and coordinate any necessary storage, network access or computation. The documentation below identifies where that responsibility appears in the source when it is evidenced.

03 · Result and feedback

The resulting screen, calculation or stored record should reflect the processed state. Circuit serialisation and OpenQASM import/export components. This capability is documented in the project material; the detail page distinguishes its intended user experience from the supporting implementation and any configuration needed to run it.

04 · Boundaries and verification

This page describes the documented behaviour, not an independently verified live deployment. Runtime configuration, permissions, test data or connected services may still be required.

PROJECT WALKTHROUGH

Modules & engineering details

How the major parts fit together and what each part contributes.

01

Circuit design and gates

The Qt UI is oriented around composing circuits from quantum gates. Circuit operations can be interpreted by the simulator using gate matrices and control qubits.

02

State-vector simulation

The C++ backend handles quantum states and applies gate operations over amplitudes. The simulator forms the numerical core for inspecting how operations transform a system.

03

Measurement and probabilities

Measurement logic derives outcome probabilities from the current state and supports simulated observation. The state vector and measured results must be distinguished in explanations.

04

Code-oriented workflow

OpenQASM-related components provide a bridge between the visual circuit description and a textual representation. This supports the planned side-by-side circuit/code design.

05

Visual research direction

Bloch-sphere exploration, step-by-step animations, comparisons and Q#/Qiskit interoperability belong to the broader roadmap and are not presented as completed modules.

Circuit, code and simulator contracts

The v0.2 specification proposes a synchronized circuit editor, code representation and state visualisation. A specification is not the same as a tested executable.

01

Canonical circuit model

A gate placed in the editor should update one common circuit representation. Code export and simulation should read this model rather than maintaining unrelated gate lists.

02

Numerical statevector core

The independent C++ simulator applies gate matrices to amplitudes, calculates measurement probabilities and can expose intermediate states to the UI.

03

Bloch sphere and mixed-state caveat

A per-qubit sphere is useful for pure qubit states; entangled subsystems require careful reduced-state interpretation. Density-matrix and noise features are later phases in the specification.

04

Learning and stepping mode

Run, pause, step and reverse inspection are proposed to connect circuits to state evolution. Guided examples include Bell states and later teleportation and Grover.

Documentation: GitHub repository / project specification. The content describes documented behaviour or plans; deployment readiness is not inferred.

03 · Explore

Project-specific preview

Single-qubit exampleSeparate web visualization · no backend
|0⟩HM

Illustrative H|0⟩: 50% / 50%

Visual studies · project-specific

Interface and system concepts

Independent illustrative views of the documented or proposed workflows. They are not connected to a running backend, and their values are not actual measurements.

Planned circuit editor · illustrative

Gate circuit and measurement

q₀H•M
q₁X⊕M

A circuit view connects gate placement to the order of matrix operations applied by a state-vector simulator.

q0 · Hq1 · XControlled gateMeasurement
Planned probability panel · illustrative

Amplitude distribution

|00⟩
|01⟩
|10⟩
|11⟩

The visual layer would plot probabilities and state evolution; diagram values are illustrative, not computed results.

|00⟩|01⟩|10⟩|11⟩
Planned state view · illustrative

Bloch sphere and phase view

A Bloch-sphere panel could complement numerical amplitudes by showing a single-qubit orientation and phase-oriented intuition for educational use.

PhaseBlochStateSingle qubit
Planned state workspace · illustrative

Statevector and matrix inspection

|ψ⟩ = [ α₀ α₁ α₂ α₃ ]
P = [ 0.50 0.00 0.00 0.50 ]

A state inspector can keep amplitudes, derived probabilities and compact matrix notation visible while the circuit changes.

VectorProbabilityMatrixInspector
Planned code sync · illustrative

OpenQASM and generated code view

qreg q[2]; h q[0]; cx q[0], q[1]; measure q[0];
Frames Gate order Export History

The interface can pair a circuit canvas with a code-oriented panel so OpenQASM import/export remains easy to inspect instead of hidden behind the visual editor.

OpenQASMExportFramesHistory
Planned experiment view · illustrative

Simulation steps and experiment timeline

Build
Simulate
Measure
Compare

A lightweight experiment timeline could help relate editing, simulation and comparison steps without pretending that the preview is a live physics result.

ExperimentSimulateMeasureCompare
04 · Source and design

Implementation examples and code walkthrough

Circuit operations, measurements and recorded simulation frames

QuantumLab/QuantumLab/core/StateVectorSimulator.cppGitHub code excerpt
C++
StateVector state(circuit.qubitCount());
SimulationResult result{state, {SimulationFrame{0, state}}, {}};
MeasurementEngine measurementEngine(randomSeed);
for (const QuantumOperation &operation : circuit.orderedOperations()) {
    if (operation.gate == GateType::Measure)
        result.measurements.push_back(measurementEngine.measureQubit(state, operation.target));
    else
        applyOperation(state, operation);
    result.frames.push_back(SimulationFrame{++completedOperations, state});
}

Computing measurement probabilities

C++

Amplitude magnitudes are squared to produce basis-state probabilities.

QuantumLab/QuantumLab/core/StateVector.cppSelected source excerpt
std::vector<double> StateVector::probabilities() const
{
    std::vector<double> values;
    values.reserve(amplitudes_.size());
    for (const Complex &amplitude : amplitudes_)
        values.push_back(std::norm(amplitude));
    return values;
}

Bell state regression check

C++

The self-test constructs an entangled two-qubit state and checks its measured probabilities.

QuantumLab/QuantumLab/core/QuantumCoreSelfTest.cppSelected source excerpt
QuantumCircuit bellCircuit(2);
bellCircuit.addOperation({GateType::Hadamard, 0, -1, 0.0, 0});
bellCircuit.addOperation({GateType::ControlledX, 1, 0, 0.0, 1});
const SimulationResult bell = simulator.run(bellCircuit);
const std::vector<double> probabilities = bell.finalState.probabilities();

Code samples are excerpts or documented illustrations; surrounding project files, configuration and dependencies may be required to compile or run them.

06 · Technology

Programming languages & stack

C++20
Qt 6
Qt Quick
QML
OpenQASM
Statevector
JSON

Core technologies and integrations used or planned for this project.

File types identified: 11 .cpp, 10 .h, 1 .qml

07 · Reality check

Status, evidence & limitations

The project status is based on repository sources and supplied documentation. It may be updated as the project evolves. A published case study is not a certification of production readiness.
  • Existing C++/QML files demonstrate a working codebase; advanced roadmap items are not presented as already shipped.
08 · Resources

Downloads & project resources

Installers appear only after a verified release is added to the public download directory. Unavailable builds are marked clearly.

↓Windows EXEComing soon↓Android APKComing soon
Source and platform support may change. An installer is not implied by the existence of source files. Desktop and Android package placeholders are shown until verified releases are published.