Project Showcase: Quantum Patterns

Quantum Patterns starts from a provocation: what if the raw material of a piece of music came from a quantum circuit, from patterns that are coherent but never repeat, and that no classical computer could fake?

It is a browser-based live-coding instrument. Partitioned quantum cellular automata (PQCA) are evolved on a quantum circuit, their measurement outcomes captured as datasets, and those datasets loaded into a fork of Satori, where you write short scripts in plain JavaScript to turn them into pitch, rhythm, timbre, texture, and space. No Python, no accounts, and no quantum background needed to start.

It is a Spring 2026 challenge project led by Peter Thomas, who performs as Cephas Teom, with Paulo Itaboraí on the quantum side. Peter comes to it from a doctorate spent trying to get quantum out of the lab and onto the stage.

I was looking at ways to make quantum computer music, and more broadly the use of quantum in the arts, more widely adopted. I used the live coding scene as a blueprint: a culture that started in academia but now has broad appeal, because of its mature ecosystem of tools and a really supportive ethos.

What makes a pattern quantum

Cellular automata evolve a grid of cells by a fixed local rule, and generative artists have long prized them for the intricate, self-organizing patterns they throw off. Partitioned quantum cellular automata run that idea on a quantum circuit: cells are qubits, the update rule is a small circuit applied across overlapping partitions, and the state evolves through superposition and interference instead of a classical lookup table.

The result is material that is coherent without being predictable. The patterns carry real quantum structure, correlations produced by entanglement and shaped by phase interference, that a classical random-number generator cannot reproduce. Three gates do most of the work:

One of the creative outputs of my thesis was cellular automata. They're really good for demonstrating, because you've got the visual element. Partitioned quantum cellular automata are really effective at some interesting, unfolding, immersive algorithms.

A cellular automaton in a dozen lines

The pattern data comes from a Qiskit and pqca script small enough to read in one sitting. It lays out a one-dimensional line of qubits, defines the two-qubit circuit applied to every cell, and steps the automaton forward, sampling one state per step. Edit the parameters, run it, and watch the excitation spread.

# PQCA quickstart: a partitioned quantum cellular automaton in a dozen lines.
import qiskit
import pqca

# Parameters
NUM_QUBITS = 10          # a 1-D line of qubits
CELL_SIZE  = 2           # qubits per cell
STEPS      = 6
INITIAL = [1] + [0] * (NUM_QUBITS - 1)   # one excitation at the left edge

# The circuit applied to every cell: a single CX on 2 qubits.
cell = qiskit.QuantumCircuit(CELL_SIZE)
cell.cx(0, 1)?Entanglement. The CX links the two qubits in a cell so their states become correlated rather than independent: the quantum core of the update rule.
# Two offset tessellations couple the update across cell borders.
tes = pqca.tessellation.one_dimensional(NUM_QUBITS, CELL_SIZE)
frames = [
    pqca.UpdateFrame(tes, cell),
    pqca.UpdateFrame(tes.shifted_by(1), cell),?Offset tiling. Shifting the second tessellation by one qubit lets information cross cell boundaries, so cells couple instead of evolving in isolation.]

# Unitary mode evolves the statevector locally, sampling one state per step.
automaton = pqca.Automaton(INITIAL, frames, mode=pqca.UnitaryPQCA())?Sampled, not collapsed. Unitary mode evolves the full statevector and samples one outcome per step without collapsing it, so the automaton keeps its quantum structure as it runs. No backend or account needed.
print(f"t=0  {INITIAL}")
for t in range(1, STEPS + 1):
    print(f"t={t}  {next(automaton)}")

Two offset tessellations are the trick: applying the update on one tiling, then a version shifted by a single qubit, lets information cross the cell borders so the automaton actually couples rather than evolving each cell in isolation. Small runs evolve locally as a statevector; larger circuits move onto real IonQ hardware, where the machine's own noise enters the pattern.

From circuit to sound

Each run of the automaton produces a stream of measurement outcomes: probabilities, amplitudes, and phase values, step by step. Those numbers are exported as JSON and become the musical material: in the browser fork of Satori, they drive pitch, rhythm, timbre, texture, and space. Satori is a terse JavaScript live-coding language, so a few lines map a dataset onto sound and you hear the result immediately, synthesized in the browser via the Web Audio API.

Because the pattern is quantum, the music inherits its character: structurally coherent, non-repeating, and full of the correlations that entanglement and interference produce. Peter frames the compositions less as fixed pieces than as systems of relationships and probabilities. More than that, they are a way of carrying ideas further than a written paper can.

It can disseminate knowledge in a way that a paper can't.

An invitation, not instructions

The project ships as a fork of Satori, pre-loaded with PQCA datasets generated on simulators and on real hardware, plus a set of worked example compositions. Example 00 just puts the data on a grid; from 01 onward, the examples show how to map it into music with the Satori language. Open it in a browser, hit Run, and start hacking. The compositions are written to be pulled apart and remixed, credited to Peter and Paulo's performance project, Teom y Puy.

We fork Satori, develop some PQCA datasets, visualize them, and put musical scripts alongside, presented as an invitation for people to start hacking it about and using them as springboards for their own ideas.

The barrier this removes is the one that has kept quantum computer music largely academic: the Python, the accounts, the hardware setup. Here it is just a browser tab and plain JavaScript. Paulo, who has spent years putting quantum algorithms on stage, sees the same opening.

This platform is already really stage-tested, and I think it can reach a lot of people.

Make it yours

Everything is open source and MIT-licensed: the Qiskit generator that produces the PQCA datasets, and the Satori fork that turns them into music. Open the live environment in a browser, load an example, and compose with quantum-derived patterns, or generate your own datasets and extend the library.