Project Showcase: QuantumCanvas

QuantumCanvas is a visual sandbox where you drag and drop quantum operations to build new algorithms, then run them on real hardware.

Its guiding line, in the project's words, is thinking in logic, computing in quantum, the idea that curiosity should be all it takes to start exploring, no background in linear algebra required.

It is built for a specific moment: you have finished the tutorials, you understand the theory at a high level, and then you hit a wall. Building a new circuit from scratch feels intimidating and repetitive. QuantumCanvas is the bridge across that gap, a place to experiment, observe patterns, and develop intuition without getting stuck behind heavy math or code.

It is a featured project from Qollab's Creative Challenge, built by Shivani Mayekar, a Georgia Tech computer-science researcher who has taught quantum to hundreds of people and kept hearing the same problem.

I love seeing the moment when something clicks. Someone who initially finds quantum computing intimidating suddenly becomes curious and engaged. Watching people discover that quantum is something they can explore rather than just admire from a distance is incredibly rewarding.

The gap after the tutorials

Shivani has spent years on the teaching side of quantum. She co-founded Qtangled and has run workshops for more than 250 people, and across all those rooms one problem kept surfacing. Learners could follow the theory at a high level, but they had almost nowhere to go next.

The same challenge came up repeatedly: how do people experiment, discover, and build intuition in quantum computing without getting stuck behind complex mathematics or code? Most learners could understand the theory at a high level, but they had very few opportunities to explore concepts in an intuitive way. QuantumCanvas grew from a simple question: how can we make experimentation and discovery easier while still teaching the underlying logic of quantum systems?

QuantumCanvas treats this as a human-computer-interaction problem as much as a physics one. It names three walls every newcomer runs into, and sets out to lower each:

• The math wall: vector spaces and unitary matrices.
• The physics wall: hardware noise, decoherence, and gate timing.
• The syntax wall: learning a low-level framework before you see a single result.

That question is the whole design brief. Not another tutorial, and not a research-grade toolchain, but a place where the post-tutorial learner can actually build something and watch what it does.

Shake, mark, boost, link

QuantumCanvas is a grid you compose on. Instead of writing code, you drag and drop a small set of plain-language operations and arrange them on the canvas, with the tool showing you both the circuit and the live state visualization side by side as you go. When you want the real thing, you run it on hardware.

Each tile maps to a genuine quantum action, and the canvas enforces the order they have to happen in:

• Shake spreads every possibility equally, the opening move from a ground state.
• Mark tags a target with a hidden signal, which only works once you have shaken into superposition.
• Boost amplifies the marked item so it becomes the one you are most likely to measure.
• Link entangles two qubits so they move together.

Shivani explored several ways to visualize quantum logic before settling on this grid. The point was to make the underlying ideas tangible without watering them down.

I wanted something that felt intuitive without losing the essence of the underlying concepts. The grid system allows people to experiment, observe patterns, and develop intuition through interaction. It stays grounded in real quantum principles while making the learning process more approachable and engaging.

Under the hood, those operations are a modular library of quantum primitives, reusable building blocks you can recombine into new algorithms. On Qollab, that library lives in the Playground as a forkable collection, so the canvas is not just a teaching demo but a starting point other people can build on.

It is all real code underneath. A bare Bell state, for instance, is just shake then link, and on Qollab the Playground runs it on hardware exactly as written:

# 'backend' is pre-created as a global on Qollab
from qiskit import QuantumCircuit

# A Bell state: shake (h) then link (cx)
circuit = QuantumCircuit(2, 2)
circuit.h(0)?Shake. A Hadamard gate puts the qubit into an even superposition of 0 and 1.circuit.cx(0, 1)?Link. A CNOT entangles qubit 1 with qubit 0, so measuring one tells you about the other.circuit.measure([0, 1], [0, 1])
print(circuit)

from qiskit.providers.jobstatus import JobStatus
import time

def main(shots=100, low_prob=0.05):
    job = backend.run(circuit, shots=shots)?Submits the circuit to real quantum hardware through Qollab. backend is provided for you.
    # Poll until the job finishes
    while True:
        status = job.status()
        print(f"Job status is {status}")
        if status is JobStatus.DONE:
            break
        time.sleep(10)

    counts = job.get_counts()
    # Filter low-probability noise
    counts = {b: c for b, c in counts.items() if c > shots * low_prob}?Drops outcomes that show up too rarely to be signal: a simple hardware-noise filter.    print(f"Counts for {shots} shots: {counts}")

Accessible and accurate

The hardest part of the project was not the interface. It was calibration, deciding how much to simplify before the physics stops being the physics.

Finding the balance between accessibility and accuracy. If you simplify too much, you lose what makes quantum mechanics meaningful. If you focus too heavily on technical rigor, the experience becomes inaccessible. Navigating that balance has been one of the most challenging and rewarding parts of building the project.

That tension is exactly why the primitives stay mapped to genuine quantum actions rather than becoming a purely classical abstraction. The goal is intuition you can carry back to real circuits, not a metaphor that falls apart the moment you leave the canvas.

Where it's headed

QuantumCanvas is open for forking, and Shivani is most excited about people specializing it for real domains.

I would love to see versions tailored to specific quantum applications. Areas like drug discovery, optimization, materials science, and logistics all present unique challenges and opportunities. It would be exciting to see people build specialized experiences that help others understand how quantum ideas connect to real-world problems.

The project's own roadmap maps that ambition onto three phases:

• Phase 1: the core translation engine that turns a visual logic map into runnable hardware code.
• Phase 2: user testing with non-quantum engineers and students to refine the experience.
• Phase 3: a public beta and a template library for logistics, art, and chemistry.

She is already extending the idea herself, with a second grid-based tool focused on quantum annealing and optimization that follows the same philosophy: make complex ideas easier to explore while keeping the intuition tied to the underlying science. For anyone just starting out, she points to two communities that moved her past reading and into building: the Qiskit Global Summer School and QWorld.

Make it yours

If you have done the tutorials and want a place to actually build, QuantumCanvas is a good first canvas. It is open for forking on both Qollab and GitHub, with a live demo you can try right now.

Looking back, QuantumCanvas has been as much a learning journey for me as it has been a tool for helping others learn quantum computing.