Comprehensive guide to using QCanvas for quantum circuit conversion, simulation, and visualization. Everything you need to build quantum applications with confidence.
A next-generation quantum computing IDE that unifies Cirq, Qiskit, and PennyLane through OpenQASM 3.0. Write quantum code in any framework, compile to OpenQASM, simulate with multiple backends, and visualize results in real-time.
Convert between Qiskit, Cirq, and PennyLane seamlessly
Execute quantum circuits with multiple backends
Visualize quantum states and measurement results
Learn quantum computing through guided examples
QCanvas addresses the critical standardization gap in multi-framework quantum programming by providing a universal intermediary that translates quantum circuits into the standardized OpenQASM 3.0 intermediate representation. This enables seamless integration, comparison, and execution of quantum circuits across different hardware platforms and software ecosystems.
Bridge the gap between quantum frameworks
Make quantum computing approachable for all
Accelerate quantum software development
Get up and running with QCanvas in minutes. Learn the basics and start building quantum circuits.
Navigate to the web application and create your account
Select your preferred quantum framework (Qiskit, Cirq, PennyLane)
Write or paste your quantum circuit code
Convert between frameworks and run simulations
# Qiskit Bell State from qiskit import QuantumCircuit qc = QuantumCircuit(2, 2) qc.h(0) # Hadamard on qubit 0 qc.cx(0, 1) # CNOT gate qc.measure_all() print(qc)
This creates a quantum entanglement between two qubits, producing the famous Bell state |Φ⁺⟩ = (|00⟩ + |11⟩)/√2
IBM's comprehensive quantum computing framework
Google's framework for near-term quantum devices
Xanadu's quantum machine learning framework
Comprehensive quantum computing tools for conversion, simulation, and visualization
Convert between Qiskit, Cirq, and PennyLane
Multiple backends for accurate simulation
Interactive charts and circuit diagrams
Learning resources and guided examples
Professional code editor with syntax highlighting and IntelliSense
Input validation, rate limiting, and secure API endpoints
Docker deployment, load balancing, and high availability
Modern, scalable architecture designed for quantum computing workflows
Frontend (Next.js) Backend (FastAPI) Quantum Processing ├── React Components ├── REST API Layer ├── Quantum Converters ├── Code Editor ├── WebSocket Manager ├── Quantum Simulator ├── Visualization ├── Service Layer └── Circuit Optimizers └── Real-time Updates └── Database Layer
Complete REST API documentation for QCanvas platform integration
Convert framework code to OpenQASM 3.0
{
"source_code": "from qiskit import...",
"source_framework": "qiskit",
"conversion_type": "classic"
}
// Response includes: qasm_code, gates, depth, qubitsCheck API health status
Execute OpenQASM 3.0 with QSim
{
"qasm_code": "OPENQASM 3.0; ...",
"backend": "cirq", // cirq, qiskit, pennylane
"shots": 1024
}
// Response includes: counts, metadata, probsexecution_time, simulation_time, memory_usage, cpu_usage, fidelity
Google's quantum computing framework with statevector simulation
IBM's comprehensive quantum SDK with QASM simulator backend
Xanadu's quantum ML framework with default.qubit device
ws://localhost:8000/ws
Live progress updates for long-running operations
Execute Python code with quantum circuits. Compile circuits, run simulations, and access results programmatically.
Compile a quantum circuit object to OpenQASM 3.0 format.
Parameters:
circuit - Circuit object from Cirq, Qiskit, or PennyLaneframework - Optional: "cirq", "qiskit", "pennylane" (auto-detected if not provided)Returns:
str - OpenQASM 3.0 code
from qcanvas import compile
import cirq
q = cirq.LineQubit.range(2)
circuit = cirq.Circuit([
cirq.H(q[0]),
cirq.CNOT(q[0], q[1]),
cirq.measure(q[0], q[1], key='result')
])
qasm = compile(circuit, framework="cirq")
print(qasm)Execute OpenQASM 3.0 code using QSim quantum simulator.
Parameters:
qasm_code - OpenQASM 3.0 code stringshots - Number of measurement shots (default: 1024, use 0 for exact statevector)backend - "cirq", "qiskit", or "pennylane" (default: "cirq")Returns:
SimulationResult - Result object with counts, probabilities, and metadata
import qsim qasm = ''' OPENQASM 3.0; include "stdgates.inc"; qubit[2] q; bit[2] c; h q[0]; cx q[0], q[1]; c[0] = measure q[0]; c[1] = measure q[1]; ''' result = qsim.run(qasm, shots=1000, backend="cirq") print(result.counts) print(result.probabilities)
Compile a circuit and execute it in a single call.
Parameters:
circuit - Circuit object from Cirq, Qiskit, or PennyLaneframework - Optional: auto-detected if not providedshots - Number of measurement shots (default: 1024)backend - Simulation backend (default: "cirq")Returns:
SimulationResult - Result object with counts, probabilities, and metadata
from qcanvas import compile_and_execute
import cirq
q = cirq.LineQubit.range(2)
circuit = cirq.Circuit([
cirq.H(q[0]),
cirq.CNOT(q[0], q[1]),
cirq.measure(q[0], q[1], key='result')
])
result = compile_and_execute(circuit, framework="cirq", shots=1000)
print(result.counts)
print(result.probabilities)The SimulationResult object returned by qsim.run() and compile_and_execute() provides comprehensive access to simulation data.
| Attribute | Type | Description | Example |
|---|---|---|---|
counts | Dict[str, int] | Measurement counts for each outcome | {'00': 512, '11': 512} |
probabilities | Dict[str, float] | Probability of each measurement outcome | {'00': 0.5, '11': 0.5} |
statevector | List[complex] | Full quantum statevector (only when shots=0) | [0.707+0j, 0+0j, ...] |
n_qubits | int | Number of qubits in the circuit | 2 |
shots | int | Number of measurement shots executed | 1000 |
backend | str | Backend used for simulation | "cirq" |
execution_time | str | Total execution time (human-readable) | "1.23ms" |
simulation_time | str | Time spent in quantum simulation | "0.98ms" |
memory_usage | str | Memory consumed during simulation | "45.2 MB" |
cpu_usage | str | CPU utilization during simulation | "12.5%" |
fidelity | float | Simulation fidelity as percentage | 100.0 |
metadata | Dict[str, Any] | Additional backend-specific metadata | {'gate_count': 5} |
You can print circuit objects directly to visualize their structure in all supported frameworks.
import cirq
q = cirq.LineQubit.range(2)
circuit = cirq.Circuit([
cirq.H(q[0]),
cirq.CNOT(q[0], q[1]),
cirq.measure(q[0], q[1])
])
print(circuit)0: ───H───@───M───
│
1: ────────X───M───from qiskit import QuantumCircuit qc = QuantumCircuit(2, 2) qc.h(0) qc.cx(0, 1) qc.measure([0, 1], [0, 1]) print(qc)
┌───┐ ┌─┐
q_0: ┤ H ├──■──┤M├
└───┘ │ ┌┴┐└╥┘
q_1: ──────┼─┤M├─╫─
│ └╥┘ ║
c: 2/══════╪══╬══╩═import pennylane as qml
dev = qml.device('default.qubit', wires=2)
@qml.qnode(dev)
def circuit():
qml.Hadamard(wires=0)
qml.CNOT(wires=[0, 1])
return qml.expval(qml.PauliZ(0))
print(qml.draw(circuit)())0: ──H──╭C──┤ ⟨Z⟩ 1: ──────╰X──┤
import cirq
from qcanvas import compile, compile_and_execute
import qsim
# Step 1: Create circuit
q = cirq.LineQubit.range(2)
circuit = cirq.Circuit([
cirq.H(q[0]),
cirq.CNOT(q[0], q[1]),
cirq.measure(q[0], q[1], key='result')
])
# Step 2: Print circuit (optional)
print("Circuit Structure:")
print(circuit)
# Step 3: Compile to QASM
qasm = compile(circuit, framework="cirq")
print("\nGenerated QASM:")
print(qasm)
# Step 4: Execute simulation
result = qsim.run(qasm, shots=1000, backend="cirq")
# Step 5: Access results
print("\nSimulation Results:")
print(f" Counts: {result.counts}")
print(f" Probabilities: {result.probabilities}")
print(f" Execution time: {result.execution_time}")
print(f" Qubits: {result.n_qubits}")
print(f" Shots: {result.shots}")
print(f" Backend: {result.backend}")
# Alternative: Compile and execute in one step
result2 = compile_and_execute(circuit, framework="cirq", shots=1000)
print(f"\nOne-step result: {result2.counts}")