Bloqade

Background and History

Bloqade was developed by QuEra Computing, a neutral atom quantum computing company founded in 2018 as a spin-off from Harvard University and MIT. QuEra’s founders include Mikhail Lukin (Harvard), Markus Greiner (Harvard), Vladan Vuletic (MIT), and Dirk Englund (MIT), who are leading researchers in the physics of ultracold atoms and Rydberg interactions. The company was established to commercialize neutral atom quantum computing technology that had been developed in these academic labs over the preceding decade.

QuEra’s hardware uses arrays of individual neutral atoms (typically rubidium) trapped in programmable 2D arrangements by optical tweezers, which are tightly focused laser beams. Quantum entanglement is generated through the Rydberg blockade mechanism: when one atom is excited to a high-energy Rydberg state, the strong dipole-dipole interaction prevents nearby atoms from being excited simultaneously. This interaction is the physical basis for both quantum gates and analog quantum simulation on neutral atom platforms.

The original Bloqade implementation was written in Julia (Bloqade.jl) and released around 2022, targeting researchers who needed high-performance emulation of Rydberg atom dynamics. A Python version followed in 2023, broadening accessibility to the wider quantum computing community. The Python package provides the same core functionality: defining atom arrangements, specifying time-dependent laser pulses (Rabi frequency and detuning), and running programs on local emulators or on QuEra’s Aquila processor through Amazon Braket.

QuEra’s Aquila processor, which supports up to 256 atoms, became available on Amazon Braket in November 2022. Aquila operates in analog mode, meaning users specify continuous Hamiltonian evolution rather than discrete gate sequences. This makes it naturally suited for quantum simulation of many-body physics and for solving combinatorial optimization problems like Maximum Independent Set, where the problem graph maps directly onto the atom arrangement and Rydberg blockade constraints.

As of 2025, Bloqade is actively developed by QuEra with regular releases. Digital (gate-based) mode for neutral atoms is under development but not yet available on Aquila hardware. The neutral atom platform is considered one of the most promising approaches for scaling quantum computers, with multiple companies (QuEra, Pasqal, Atom Computing, and others) pursuing the technology. Bloqade’s programming model is distinct from gate-based frameworks, which can present a learning curve for developers familiar with Qiskit or Cirq, but it reflects the native physics of the hardware.

Overview

Neutral atom quantum computers work differently from superconducting or trapped-ion systems. Individual atoms are held in place by focused laser beams called optical tweezers and arranged in programmable 2D arrays. Quantum gates are implemented through the Rydberg interaction: when an atom is excited to a high-energy Rydberg state, nearby atoms feel a strong dipole interaction that shifts their energy levels, creating the entanglement needed for computation.

Bloqade is QuEra’s primary software tool for this hardware. It exposes two programming modes:

• Analog mode: you specify a time-varying laser pulse (the drive) and the atoms evolve continuously under the Rydberg Hamiltonian. This is the native mode of QuEra’s Aquila processor, available on AWS Braket.
• Digital mode: gate-based programming for future digital neutral atom hardware. This is in active development and not yet available on Aquila.

Most current Bloqade use is in analog mode, which maps naturally onto quantum simulation of many-body physics and combinatorial optimisation problems.

Installation

Python package:

pip install bloqade

Julia package (Bloqade.jl, which supports more emulation backends):

using Pkg
Pkg.add("Bloqade")

For AWS Braket hardware submission from Python, also install:

pip install bloqade[braket]

Core Concepts

Atom Register

The register defines where atoms sit in 2D space. Positions are given in micrometers. Bloqade provides helpers for common lattice geometries:

from bloqade.atom_arrangement import Square, Honeycomb, Chain, Triangular

square_array = Square(3, lattice_spacing=5.0)      # 3x3 grid, 5 um spacing
chain = Chain(5, lattice_spacing=6.0)              # 5 atoms in a line
custom = start.add_position([(0, 0), (5, 0), (2.5, 4.3)])  # arbitrary positions

The Rydberg Hamiltonian

The Hamiltonian Bloqade implements is:

H(t) = (Omega(t)/2) * sum_i X_i - delta(t) * sum_i n_i + sum_{i<j} V_ij n_i n_j

where:

• Omega(t) is the Rabi frequency (how strongly the laser drives transitions)
• delta(t) is the detuning (how far the laser is tuned from the atomic resonance)
• V_ij = C6 / r_ij^6 is the Rydberg interaction between atoms i and j
• n_i is the Rydberg excitation operator for atom i (1 if excited, 0 if ground)

You control the pulse shape of Omega(t) and delta(t) over time.

Drive and Sequence

A drive is a time-varying function assigned to a Hamiltonian parameter. A sequence combines the register with its drives into a complete program.

from bloqade import start

program = (
    start
    .add_position([(0, 0), (5, 0)])
    .rydberg.rabi.amplitude.uniform
    .piecewise_linear(
        durations=[0.5, 1.0, 0.5],
        values=[0, 15.7, 15.7, 0]
    )
)

piecewise_linear defines a pulse with linear ramps between the listed values over the listed durations (in microseconds). The values are in units of MHz (megahertz) for Rabi frequency.

Emulation

Run the program on a local CPU emulator:

emulation_result = program.bloqade.python().run(100)
report = emulation_result.report()
print(report.bitstrings())     # list of bitstrings from each shot
print(report.counts())         # dictionary of outcome counts

Code Examples

Defining a Square Atom Array and Running a Pulse

from bloqade import start
from bloqade.atom_arrangement import Square

# 3x3 square lattice with 5 micrometer spacing
program = (
    Square(3, lattice_spacing=5.0)
    .rydberg.rabi.amplitude.uniform
    .piecewise_linear(
        durations=[0.5, 1.0, 0.5],      # microseconds
        values=[0, 15.7, 15.7, 0]        # MHz (pi pulse area ~ 15.7 MHz * 1 us)
    )
)

# Local emulation with 100 shots
emulation_result = program.bloqade.python().run(100)
report = emulation_result.report()

# Inspect outcomes
bitstrings = report.bitstrings()
print(f"Number of shots: {len(bitstrings)}")
print(f"First 5 bitstrings: {bitstrings[:5]}")
print(f"Counts: {report.counts()}")

Adding Detuning

A common pattern is to ramp the detuning from negative to positive while holding Rabi frequency constant, which implements an adiabatic protocol:

from bloqade import start
from bloqade.atom_arrangement import Chain

program = (
    Chain(4, lattice_spacing=6.0)
    .rydberg.rabi.amplitude.uniform
    .piecewise_linear(
        durations=[0.3, 1.5, 0.3],
        values=[0, 15.7, 15.7, 0]
    )
    .detuning.uniform
    .piecewise_linear(
        durations=[0.3, 1.5, 0.3],
        values=[-20, -20, 20, 20]    # MHz, sweep from negative to positive
    )
)

result = program.bloqade.python().run(200)
print(result.report().counts())

Custom Atom Positions

For problems like Maximum Independent Set, you encode the problem graph as atom positions:

from bloqade import start

# Triangle: three atoms forming a triangle
program = (
    start
    .add_position([(0.0, 0.0), (6.0, 0.0), (3.0, 5.2)])
    .rydberg.rabi.amplitude.uniform
    .piecewise_linear(
        durations=[0.4, 1.2, 0.4],
        values=[0, 15.7, 15.7, 0]
    )
    .detuning.uniform
    .piecewise_linear(
        durations=[0.4, 1.2, 0.4],
        values=[-15, -15, 15, 15]
    )
)

result = program.bloqade.python().run(500)
print(result.report().counts())

Submitting to Aquila on AWS Braket

from bloqade import start
from bloqade.atom_arrangement import Chain
import boto3

program = (
    Chain(3, lattice_spacing=6.0)
    .rydberg.rabi.amplitude.uniform
    .piecewise_linear(
        durations=[0.3, 1.0, 0.3],
        values=[0, 15.7, 15.7, 0]
    )
)

# Requires AWS credentials and Braket access
hardware_result = (
    program
    .braket.aquila()
    .run_async(shots=100)
)

job = hardware_result.fetch()
print(job.report().counts())

This requires an AWS account with Braket enabled. Aquila jobs are queued and typically complete within minutes to hours depending on demand.

Backends

Backend	How to invoke	Notes
Local Python emulator	.bloqade.python().run(shots)	CPU-based, exact for small systems
Bloqade.jl emulator	Julia package	GPU-accelerated, handles larger systems
QuEra Aquila (real hardware)	.braket.aquila().run_async(shots)	Up to 256 atoms, requires AWS account

Use Cases

Neutral atom hardware and analog simulation with Bloqade are well-suited to:

• Quantum simulation of many-body physics: the Rydberg Hamiltonian naturally realises Ising-like spin models, making it useful for studying phase transitions and correlated quantum systems.
• Combinatorial optimisation: Maximum Independent Set on unit-disk graphs maps directly onto the ground state of the Rydberg Hamiltonian. Atoms within the blockade radius cannot both be excited, which enforces the independence constraint.
• Quantum annealing analog: slowly sweeping the detuning from negative to positive implements an adiabatic protocol that can find low-energy states of the encoded problem.

Limitations

• Analog mode only supports the Rydberg Hamiltonian form. You cannot implement arbitrary gate sequences in analog mode; the physics constrains which operations are native.
• The programming model is significantly different from gate-based frameworks like Qiskit or Cirq. Developers familiar with gate-based quantum computing face a steeper conceptual transition.
• Hardware access via Aquila requires an AWS Braket account and incurs cloud costs.
• Local emulation is limited to small systems (roughly 20 or fewer atoms for exact simulation) due to the exponential state space.
• Digital mode for neutral atoms is under active development and not yet available on Aquila.