Quantum for
Software Developers
Quantum for
Software Developers
Enhance your software development skills by diving into quantum programming.
Launch qBraid
Already have an account?
Log in
Write smarter, code faster.
The Quantum Console VSCode extension pack provides a powerful interface for quantum computing workflows, enabling seamless management of quantum jobs and devices using qBraid. The Quantum Console extension pack requires a qBraid API Key.
qBraid Lab is the quantum computing industry's definitive cloud-based IDE, delivering seamless software environments, GPU integration, and direct quantum hardware access—empowering developers with unprecedented quantum development efficiency.
Environment Management
Maintain control over your python environments both locally and on qBraid Lab. On Lab, 30+ tricky environments such as Nvidia GPU configuration, QuEra Bloqade, Juliam and the C++ Intel Quantum SDK are also available out-of-the-box.
import qiskit.circuit.library as lib
from qiskit import QuantumCircuit
from qiskit.quantum_info import SparsePauliOp
from qiskit.synthesis import SuzukiTrotter
from qbraid.runtime import QbraidProvider
terms = [("ZZ", 1.0), ("XI", 0.5)]
h = SparsePauliOp.from_list(terms)
params = (h, 0.1, None, SuzukiTrotter(reps=1))
gate = lib.PauliEvolutionGate(*params)
ckt = QuantumCircuit(h.num_qubits)
ckt.append(gate, range(ckt.num_qubits))
provider = QbraidProvider()
device = provider.get_device("qbraid_qir_simulator")
job = device.run(ckt, shots=100)import numpy as np
from bloqade.atom_arrangement import Square
from qbraid.runtime import QbraidProvider
provider = QbraidProvider()
device = provider.get_device("quera_aquila")
ahs_program = (
Square(3, lattice_spacing="lattice_spacing")
.rydberg.rabi.amplitude.uniform.piecewise_linear(
durations=[0.4, 3.2, 0.4],
values=[0.0, "max_rabi", "max_rabi", 0.0],
)
.assign(max_rabi=15.8, max_detuning=16.33)
.batch_assign(
lattice_spacing=np.arange(4.0, 7.0, 1.0)
)
)
job_batch = device.run(ahs_program, shots=50)from qbraid import load_program, transpile
from braket.experimental.algorithms import (
bernstein_vazirani as bv
)
bk_circ = bv.bernstein_vazirani_circuit("010101")
qprogram = load_program(bk_circ)
num_qubits = qprogram.num_qubits
stim_circ = transpile(qprogram.program, "stim")
stim_circ.append_operation("M", range(num_qubits))
sampler = stim_circ.compile_sampler()
results = sampler.sample(shots=100)import cudaq
import numpy as np
from qiskit import QuantumCircuit
from qbraid import transpile
n = 5
qc = QuantumCircuit(n, n)
qc.h(range(n))
for i in range(n):
for j in range(i + 1, n):
qc.cp(2 * np.pi / (2 ** (j - i + 1)), i, j)
for i in range(n // 2):
qc.swap(i, n - i - 1)
qc.measure_all()
kernel = transpile(qc, "cudaq")
result = cudaq.sample(kernel)from qbraid.runtime import QbraidProvider
qc = """
OPENQASM 3.0;
qubit[3] q;
gpi(0.5) q[0];
gpi2(0) q[1];
ms(0,0.5, 0.25) q[1], q[2];
"""
provider = QbraidProvider()
device = provider.get_device("ionq_simulator")
job = device.run(qc, shots=100, noise_model="aria-1")
result = job.result()
print(result.data.get_counts(decimal=True))from pyqubo import Spin
from qbraid.runtime import QbraidProvider
from qbraid.runtime.schemas import QuboSolveParams
s1, s2, s3, s4 = [Spin(f"s{i}") for i in range(1, 5)]
H = (4 * s1 + 2 * s2 + 7 * s3 + s4) ** 2
model = H.compile()
qubo, offset = model.to_qubo()
params = QuboSolveParams(offset=offset)
provider = QbraidProvider()
device = provider.get_device("nec_vector_annealer")
job = device.run(qubo, params=params)
result = job.result()
solutions = result.data.solutions()from pyquil import Program
from pyquil.gates import CNOT, H, X
from qbraid import QbraidProvider
secret = "10110"
p = Program()
n = len(secret)
p.inst([H(i) for i in range(n)] + [X(n), H(n)])
for i in range(n):
if secret[i] == "1":
p.inst(CNOT(i, n))
p.inst([H(i) for i in range(n)])
provider = QbraidProvider()
device = provider.get_device("aws_sv1")
job = device.run(p, shots=100)
result = job.result()
counts = result.data.get_counts() import cirq
from qbraid import QbraidProvider
from qbraid.visualization import animate_qpu_state
qubits = cirq.LineQubit.range(10)
circ = cirq.Circuit(
[cirq.H(qubits[0])]
+ [cirq.CNOT(qubits[0], q) for q in qubits[1:]]
)
provider = QbraidProvider()
device = provider.get_device("quera_qasm_simulator")
job = device.run(circ, shots=100, backend="cirq-gpu")
result = job.result()
animate_qpu_state(result.data.get_qpu_state())
No Vendor Lock-In
Use your qBraid managed API token to access 20+ devices and more, or use your own key with the qbraid-provider-class.
When I taught a quantum computing class with 75 students, instead of spending the first few weeks helping students setting up their environment, with qBraid, everyone was up and running in under 15 mins.
Our organization has engaged with qBraid holistically: research, platform development, running educational events. The technical capacity of their team is undeniable, and so is their relentless pursuit to deliver quality products and experience to their partners and customers. With qBraid, hundreds of trainees and research teams have engaged with our Aquila quantum computer within a few clicks, an experience hard to reproduce through other distribution services.
With the Fire Opal environment on qBraid, it's easy for anyone to leverage Q-CTRL's error suppression pipeline to maximize performance of quantum hardware. Instead of spending time setting up, you can simply install the environment and run valuable quantum applications with the best possible performance.
qBraid is the quantum computing shopping mall. If you go there, you can probably find the cloud service and quantum hardware you're looking for with advanced integration and frameworks.
qBraid Lab and qBraid SDK are the perfect companion tools for managing research workflows. Accessing the latest devices and rapidly coding tests without the headache of installation has been amazing for me and my research group.
QuSTEAM offers our undergraduate course modules using the qBraid platform because it's easy for students to start running quantum programs on different kinds of QPUs, right away. It's easy for the instructor to manage the educational materials, provide starter code, and manage QPU credits as their students progress through projects.
qBraid helped the NYUAD Hackathon empower a new generation of computer scientists with the necessary collaborative, cross-border skills to advance quantum computing capabilities here in Abu Dhabi and ultimately make a positive impact on our society. Leading up to the hackathon the quantum experts and the domain experts held many workshops for the student hackers many of whom were introduced to quantum computing with qBraid for the first time.
Getting quantum computing resources in the hands of users far and wide is one of our main aspirations. Working with qBraid now enabled an exciting new pipeline, and a simple and functional one, that users can use to deploy the most innovative solutions with some of the largest and most unique quantum computing resources in the world!
