Project Showcase: QAVE

What does a quantum algorithm actually look like while it's running? Not the math on paper. The actual state, evolving gate by gate.

QAVE (Quantum Algorithm Visualization Engine) answers that question visually. QAVE computes the quantum state at every gate operation, synchronizes multiple views into a single coherent replay, and makes quantum errors and their corrections directly observable. Not a diagram. Not a static plot. A full animation of what's happening inside the circuit as it runs.

QAVE is a featured project from Qollab's first Quantum Creative Challenge. It addresses a gap that Inho noticed even with years of research experience: the distance between how algorithms are formally described and how intuitively they can be understood.

Making the invisible visible

Inho Choi is not new to quantum. He's a researcher working at the intersection of quantum physics and computation, drawn to fundamental open problems where new mathematical and algorithmic tools are still needed.

But deep expertise didn't shield him from a frustration shared by students and researchers alike: quantum algorithms are hard to follow, and not always because of the math.

The most interesting thing for me has been seeing how much more understandable a quantum circuit and density matrix becomes once the evolution is made visible step by step. Many ideas in quantum computing feel difficult not only because of the math, but also because we often lack the right way to see them.

That observation became the starting point for QAVE. He wanted to close the gap between formal description and genuine understanding. Not by simplifying the science, but by giving it a visual layer that carries real information.

How Inho built QAVE

The core design decision behind QAVE is that everything stays in sync. The engine computes the full quantum state at every step of a gate operation and locks multiple views together into one replay. State vector, density matrix, gate effects. All moving in lockstep.

That matters most when things go wrong. Quantum errors are physical events with specific signatures, and understanding how they propagate through a circuit is central to building reliable quantum systems. Most tools leave that as something you reconstruct from equations after the fact. QAVE makes it something you watch happen.

The result is a tool built for educators and researchers who want a transparent, grounded way to see how quantum algorithms actually behave. Not an approximation. The real evolution, made visible.

The whole workflow is a short, runnable notebook. This is the core of it: build a circuit, generate a deterministic trace, and render the synchronized animation you just watched.

# QAVE turns a Qiskit circuit into a deterministic, replayable animation.
from qiskit import QuantumCircuit
from qiskit.quantum_info import Statevector
from qave import SimulationOptions, generate_trace_from_qiskit
from qave.notebook import render_animation, display_animation, resolve_notebook_render_options
from IPython.display import display

# Build a 3-qubit GHZ circuit
circuit = QuantumCircuit(3, 3, name="ghz3")
circuit.h(0)?Superposition. Puts qubit 0 into an equal mix of |0⟩ and |1⟩.circuit.cx(0, 1)?Entangle. Links qubit 1 to qubit 0.circuit.cx(0, 2)?Entangles qubit 2 as well: the full GHZ state |000⟩ + |111⟩.circuit.measure(range(3), range(3))

# Confirm an equal superposition of |000⟩ and |111⟩ before measuring
psi = Statevector.from_instruction(circuit.remove_final_measurements(inplace=False))

# Generate a deterministic trace: the state computed at every step of every gate
options = SimulationOptions(algorithm_id="ghz", mode="preview", seed=24, shot_count=100)
result = generate_trace_from_qiskit(circuit, options=options)?Emits a versioned trace.json with physically-computed in-gate evolution samples.
# Deterministic measurement replay: same seed, same shots, every time
replay = result.require_measurement_shot_replay()?Repeatable shot outcomes, so the animation replays identically every run.
# Render the synchronized circuit / amplitude / probability animation
render = resolve_notebook_render_options(width=1280, height=720, fps=60)
anim = render_animation(result, render=render)
display(display_animation(anim))?The synchronized replay above (Fig. 1), rendered to MP4 with a GIF fallback.

Where others could take it

QAVE is open for forking. When asked what directions excite him most, Inho pointed to several.

The near-term add-ons that excite me most are already visible in the roadmap: a realistic noise mode so users can compare ideal and hardware-like behavior, a tensor-network or MPS view that makes larger circuits and entanglement structure easier to explore, and a hybrid-loop mode for VQE or QML that shows how the quantum circuit and the classical optimizer co-evolve over many iterations.

Longer term, Inho is excited by a hardware-aware layer on top of that.

Visualizing how an algorithm is implemented on different platforms and how noise propagates from the physical device to the final algorithmic performance.

He also has a clear picture of what a companion project could look like.

If I built a companion project on Qollab with the same setup, it would probably focus on the hardware layer itself. A visual explorer or lightweight simulator that compares how the same logical circuit is realized on superconducting, trapped-ion, and neutral-atom platforms, and how they affect performance end to end. I think there is real value in helping people see how quantum computing is implemented and run on different physical hardware.

The foundation is there. Someone with the right interest could pick up any of these threads.

Finding your way in

Inho's connection to quantum runs deeper than a research interest. It started with a question about computation and nature.

What made me feel that I belonged in quantum was that it spoke directly to a question I had already cared about for a long time: how to understand and simulate nature faithfully. Quantum computation felt like the framework that resolves the bottleneck. As Feynman put it, if nature is fundamentally quantum, then simulating it properly may require computation that is quantum as well.

That idea stayed with him from the beginning. It made quantum computing feel like a natural path, not a career pivot. And it shapes how he thinks about accessibility. He believes conceptual clarity and scientific rigor should go together, and that how we teach quantum science matters as much as the science itself. QAVE is that belief turned into a tool.

Inho's advice for finding community in quantum is simple:

Start small and be visible. Find an active recurring group, whether that is a local seminar, an online study group, or an open-source project, and participate consistently. You do not need to impress people. You just need to engage honestly with the material. In my experience, community starts to form when you stop trying to learn everything alone and start sharing your questions, your attempts, and your progress with others.

Make it yours

If you're curious about what quantum circuits actually do at each step, QAVE is a good place to start. The project code is open for forking on both Qollab and GitHub.