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.
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.
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
Code samples are excerpts or documented illustrations; surrounding
project files, configuration and dependencies may be required to
compile or run them.
05 · Visual material
Interface & screenshots
Screenshots from supplied documentation and repository media.
Missing visuals remain placeholders rather than invented screens.
▧
No verified product screenshot yet
To fill this space, add an approved screenshot with the exact
filename shown below. The site currently displays a neutral
placeholder.
assets/img/projects/quantumlab/screenshot-01.webp
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.
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.