Project Showcase: qOrbital

When a chemist draws a molecule, the electrons are not really dots. They are fuzzy clouds of probability. qOrbital computes those clouds for small molecules on real quantum hardware, then lets you look at them.

Pick a molecule (H₂, HeH⁺, LiH), drag a bond-length slider, and a full quantum-chemistry pipeline runs underneath: classical integrals from PySCF, a qubit Hamiltonian from Qiskit Nature, and a ground state found by VQE on IonQ. From that state qOrbital reconstructs the electron density and renders it.

Most VQE demos report a single energy number and leave the uncertainty behind it out of the picture. qOrbital puts that uncertainty on screen.

Two ways to see an electron

What does an orbital actually look like? Quantum mechanics gives two famous answers, and qOrbital shows both from the same wavefunction.

• Copenhagen, the textbook one: a probability cloud, rendered as a 3D density isosurface.
• Bohmian: the same wavefunction, with a velocity field computed from its phase and particle trajectories integrated through it.

Drop a handful of seed particles into the Bohmian view and they trace the orbital rather than filling it. Paths bend around nodes and crowd where the bonding density is highest.

Whenever I would look for those intuitive probability "cloud" graphs I would see on Google for more complicated systems like molecules, I would get something completely unrecognizable from the simple hydrogen graphs I was familiar with. Since then, I've been thinking about ways to make quantum concepts a little more reachable using visualizations, since they are famously unintuitive.

You set a molecule and a geometry, and the orbital responds in real time as you move the slider, with a live dashboard showing the VQE optimizer working its way toward the ground state.

Noise you can see

Bohmian trajectories need a high-fidelity wavefunction, so every hardware run carries the full fingerprint of finite measurement statistics. Overlay many independent IonQ runs and you get a trajectory uncertainty cloud.

Where the physics is robust, the trajectories pile up sharp and clean. Near nodes, where the wavefunction is most fragile, they smear out. The error becomes a shape you can read.

You can see where a trapped-ion processor is sure and where it is not.

The goal wasn't to build something research-grade here, it was to show people an honest picture of quantum physics, and that includes the hardware we run it on. As a plus, it's a neat reminder that you are watching code that was computed, information that was transferred by blasting lasers at atoms.

To make that explorable without a hardware queue, real runs on IonQ Aria and Forte are bundled as a gallery of independent results per molecule, so visitors can browse genuine hardware output, run-to-run variation and all, while a clean Aer statevector simulator provides the "this is what perfect looks like" baseline.

The team does not consider that view finished. "We aren't fully satisfied with the current implementation of showcasing hardware noise," Aryan says, "and we have some exciting plans to better acknowledge the faults of current hardware." The end they are aiming at is to show people why it is hard to build a useful quantum computer at scale.

How it works

The pipeline is a real quantum-chemistry stack, end to end: PySCF builds the classical integrals and a Hartree-Fock reference, Qiskit Nature maps the fermionic problem to qubits, VQE finds the ground state, and the optimized state is turned back into a density grid and a Bohmian velocity field for rendering. The core loop is small enough to run yourself, and on Qollab it runs as written:

# qOrbital quickstart: find a molecule's ground state with VQE.
import numpy as np
from qiskit.primitives import StatevectorEstimator
from qiskit_algorithms import VQE
from qiskit_algorithms.optimizers import SLSQP
from qiskit_nature.second_q.circuit.library import UCCSD, HartreeFock
from qiskit_nature.second_q.drivers import PySCFDriver
from qiskit_nature.second_q.mappers import JordanWignerMapper

MOLECULE, BOND = "H2", 0.735          # also: HeH+, LiH

# 1. Classical chemistry: Hartree-Fock + molecular integrals
problem = PySCFDriver(atom=f"H 0 0 0; H 0 0 {BOND}", basis="sto-3g").run()?Classical setup. PySCF runs Hartree-Fock and builds the molecular integrals. This is also the classical baseline qOrbital compares against.​

# 2. Fermions to qubits
mapper = JordanWignerMapper()?Mapping. Turns the fermionic Hamiltonian into qubit operators. LiH instead uses parity mapping with a 2-qubit reduction to keep the qubit count down.​
qubit_op = mapper.map(problem.hamiltonian.second_q_op())

# 3. UCCSD trial state, from the Hartree-Fock reference
hf = HartreeFock(problem.num_spatial_orbitals, problem.num_particles, mapper)
ansatz = UCCSD(problem.num_spatial_orbitals, problem.num_particles, mapper, initial_state=hf)?Ansatz. UCCSD is the trial wavefunction. VQE tunes its parameters to push the energy down to the true ground state.​

def show(step, params, energy, meta):
    print(f"  iter {step:>3}   E_elec = {energy:+.6f} Ha")?The descent. VQE walks downhill: each step the optimizer nudges the circuit and the energy drops. This callback feeds the live convergence dashboard.​

vqe = VQE(StatevectorEstimator(), ansatz, SLSQP(maxiter=100),
          callback=show, initial_point=np.zeros(ansatz.num_parameters))
result = vqe.compute_minimum_eigenvalue(qubit_op)

total = result.eigenvalue.real + problem.hamiltonian.nuclear_repulsion_energy?Electronic energy plus nuclear repulsion is the molecule's ground-state energy. qOrbital rebuilds the electron density and Bohmian trajectories from this state.​
print(f"  ground state = {total:+.6f} Ha")

From the converged state, qOrbital extracts the one-particle reduced density matrix to rebuild the electron density on a 3D grid, computes the de Broglie-Bohm velocity field v = (ℏ/m) Im(∇ψ/ψ) and integrates it with adaptive Runge-Kutta for the trajectories, then renders both with Three.js on the web and PyVista in the lab.

Make it yours

The beautiful thing about quantum computing is that everybody has something to bring to the table. There are so many disciplines that make up this field, and quantum physics doesn't have to be the only language you speak.

qOrbital is open and forkable on Qollab, the full package is MIT-licensed on GitHub, and you can try the hosted demo right now. Swap the molecule, change the bond length, seed your own particles, and rerun the VQE on a simulator or real IonQ hardware. Supported molecules today are H₂ (the tutorial baseline), HeH⁺ (polar asymmetry), and LiH (the main showcase).