Quobly Alloy Forge

Alloy Forge is Quobly’s physics-based emulator of Pioneer, their 10-qubit silicon spin-qubit QPU. Quobly builds qubits from electron spins in silicon, manufactured on standard CMOS processes, so the error model the emulator reproduces is a semiconductor one rather than the superconducting or trapped-ion behavior you may be used to.

The emulator goes wider than the hardware: 15 qubits, in both noiseless and noisy modes, on a linear nearest-neighbor coupling map.

Quick start

from qbraid.runtime import QbraidProvider
from qiskit import QuantumCircuit

provider = QbraidProvider()
device = provider.get_device("qbraid:quobly:sim:alloy-forge")

circuit = QuantumCircuit(2)
circuit.h(0)
circuit.cx(0, 1)
circuit.measure_all()

job = device.run(circuit, shots=200)
print(job.result().data.get_counts())
# {'00': 106, '11': 92, '01': 1, '10': 1}

One thing in that output surprises almost everyone: the distribution is not clean, because noise is on by default.

Runtime options

Alloy Forge takes three device options. They are passed as a dict through runtime_options, not as keyword arguments:

job = device.run(circuit, shots=200, noise=False)
# TypeError: QbraidDevice.submit() got an unexpected keyword argument 'noise'

job = device.run(circuit, shots=200, runtime_options={"noise": False, "seed": 42})

noise is on by default

Unlike most simulators on qBraid, Alloy Forge applies its hardware noise model unless you tell it not to. A plain device.run(circuit, shots=200) is a noisy run.

ideal = device.run(circuit, shots=200, runtime_options={"noise": False})
noisy = device.run(circuit, shots=200, runtime_options={"noise": True})

The distinction is the point of the device — a noiseless run of a Bell pair gives you exactly two outcomes, while the noisy run shows what Pioneer’s silicon spin qubits would actually return.

seed makes noisy runs reproducible

Two runs with the same seed return bit-identical counts, noise included:

opts = {"noise": True, "seed": 42}
device.run(circuit, shots=1000, runtime_options=opts).result().data.get_counts()
# {'00': 513, '11': 484, '10': 3}
device.run(circuit, shots=1000, runtime_options=opts).result().data.get_counts()
# {'00': 513, '11': 484, '10': 3}

Use it for anything you need to reproduce: notebooks, tests, tutorials, recorded demos.

Reading the results

Counts match your circuit’s width

Results come back at your circuit’s own width — a two-qubit circuit returns two-bit keys.

Qubit ordering is little-endian: qubit 0 is the rightmost bit.

circuit = QuantumCircuit(3)
circuit.x(2)
circuit.measure_all()

device.run(circuit, shots=100, runtime_options={"noise": False}).result().data.get_counts()
# {'100': 100}
#   ^ qubit 2

Native gates and the coupling map

Pioneer’s native gate set is RX, RY, RZ for single-qubit rotations and RZZ for the two-qubit interaction. RZZ is only physically available between adjacent qubits on the linear array: 0–1, 1–2, 2–3, and so on.

You do not have to write circuits in that gate set. Decomposition happens inside the emulator, after submission:

device.transform(qasm)  # returns the program unchanged -- this is a no-op for Alloy Forge

Unlike Rigetti or IonQ, qBraid does not rewrite your gates for this device. An h/cx circuit reaches Quobly as h/cx and Quobly transpiles it to RX/RY/RZ/RZZ on its side.

A GHZ state written as a nearest-neighbor ladder satisfies that constraint with no routing at all:

def ghz(n: int) -> QuantumCircuit:
    qc = QuantumCircuit(n)
    qc.h(0)
    for i in range(n - 1):
        qc.cx(i, i + 1)     # every pair is adjacent
    qc.measure_all()
    return qc

Execution time

Alloy Forge integrates the physics shot by shot, so the shot count dominates the wall clock, more than circuit width does. The same 4-qubit GHZ circuit:

Roughly 20 seconds of fixed overhead plus a per-shot cost. Across a 2-to-9 qubit GHZ sweep at 200 shots, individual jobs ran from 22 s to 89 s.

Example: measuring noise accumulation

Growing a GHZ chain one qubit at a time is a direct read on how quickly the Pioneer error model accumulates. The metric is the share of shots landing in |0…0⟩ or |1…1⟩, which is 100% for an ideal GHZ state.

from qbraid.runtime import QbraidProvider
from qiskit import QuantumCircuit

device = QbraidProvider().get_device("qbraid:quobly:sim:alloy-forge")
SHOTS = 200

for n in range(2, 10):
    qc = QuantumCircuit(n)
    qc.h(0)
    for i in range(n - 1):
        qc.cx(i, i + 1)
    qc.measure_all()

    job = device.run(qc, shots=SHOTS, runtime_options={"noise": True, "seed": 1234})
    counts = job.result().data.get_counts()
    population = (counts.get("0" * n, 0) + counts.get("1" * n, 0)) / SHOTS
    print(f"GHZ-{n}: {population:.1%}")

Measured on the live device:

The noiseless column is flat at 100% by construction; the noisy column is the emulator’s answer to “how big a GHZ state can Pioneer hold together?”

Troubleshooting

Related links

• QbraidProvider: installation, authentication, device discovery
• Runtime Options: the pipeline options set with set_options()
• Pricing: Alloy Forge is free to run
• Quantum jobs: tracking submissions in qBraid Lab
• Quobly: silicon spin qubits on standard CMOS processes