Native MLX state-vector simulation that beats Qiskit Aer and PennyLane on your own Mac.
Qupertino is a three-part project: a self-published technical report, the Qupertino simulator stack, and the dedicated QuantumStudio desktop UI studio. There is no native MLX quantum simulator available today, so Qupertino provides a local simulator layer for QFT, QAOA, VQE, Hamiltonian workflows, and OpenQASM runs.
It runs in two tiers on the same hardware: a pure-MLX array-kernel tier, and an opt-in tier of hand-written Metal shaders covering every structured layer family. On an M1 Max the Metal tier is fastest in all 18 comparison cells against Qiskit Aer CPU and PennyLane lightning.qubit — 25-qubit QFT in 59 ms (47× Aer, 95× PennyLane, and faster than MLX's own mx.fft) — and accelerates 26 of 29 workloads up to 25× over the pure tier.
Representative measurements from the M1 Max evaluation setup in the technical report (32 GB unified memory, Apple Silicon, MLX backend).
| Algorithm @ 25 qubits | Metal tier (s) | Pure MLX (s) | Notes (same-machine, gate-identical, interleaved) |
|---|---|---|---|
| QFT | 0.059 | 0.721 | Aer CPU 2.80, lightning.qubit 5.61; Metal beats mx.fft (0.077) |
| QAOA (ring, 6 layers) | 0.150 | 2.07 | Aer 5.35, lightning 6.84 |
| TFIM Hamiltonian Simulation (20 steps) | 0.495 | 5.82 | Aer 17.79, lightning 32.95 |
| Phase Estimation | 0.105 | 0.91 | Aer 4.05, lightning 6.06 |
| Grover (diffusion proxy) | 0.052 | 1.11 | Aer 1.21, lightning 2.73 |
| GHZ | 0.022 | 0.27 | Aer 0.69, lightning 0.42 |
| Long-range Ising (all-to-all) | 0.615 | 14.8 | Full-suite paired sweep; 300 bonds in one weighted pass (24×) |
| Heisenberg chain (Trotter) | 1.71 | 23.1 | Full-suite paired sweep; Walsh-conjugated XX/YY layers (13.8×) |
QuantumStudio combines research, software, and pedagogy in one workflow that moves from theory to execution to verification.
The report, "Qupertino: Structured-Gate Kernel Dispatch for Quantum Circuit Simulation on Apple Silicon with MLX," is a self-published technical write-up that defines the benchmark methods, hardware assumptions, algorithm coverage, and measured results on Apple Silicon, including same-machine Qiskit Aer CPU and PennyLane lightning.qubit baselines on gate-identical circuits.
The report is unpublished; the PDF and LaTeX source are not currently distributed.
Qupertino is the local simulation engine. It implements state-vector execution, gate libraries, algorithm routines, and OpenQASM support for reproducible runs on macOS.
QuantumStudio is the dedicated desktop UI studio for configuring runs, launching benchmark suites, monitoring execution, and exporting structured artifacts for analysis and reporting around the benchmark workflow.
Qupertino productizes the core results from our technical report on MLX-native quantum simulation with structured-gate kernel dispatch on Apple Silicon.
Most high-performance quantum simulators are optimized around CUDA and discrete GPU memory models. Apple Silicon works differently: CPU and GPU share one unified memory pool, which removes explicit host-device copies and simplifies the programming model. Qupertino ships two measured performance tiers. The pure-MLX tier uses structured-gate kernel dispatch: diagonal gates run as broadcast phase multiplies, controlled gates as masked half-state updates, and SWAP as an axis permutation, all in MLX array operations. The Metal shader tier (one flag: MLXQ_METAL_KERNELS=1) adds hand-written kernels for every structured layer family — phase-LUT diagonals, GF(2) permutation gathers that run any CNOT/X/SWAP block as one pass, fused single-qubit layers, radix-4 QFT and Walsh–Hadamard butterflies — reached through fusion detectors that preserve circuit semantics exactly and are parity-tested against the pure path.
In our M1 Max evaluations (32 GB unified memory, four-way interleaved ten-repeat protocol on gate-identical circuits), the Metal shader tier is fastest in all 18 comparison cells against Qiskit Aer CPU and PennyLane lightning.qubit: 25-qubit QFT completes in 59 ms (47× over Aer, 95× over PennyLane, paired per-repeat ratios), TFIM Trotter evolution in 0.50 s (36× and 67×), and GHZ preparation in 22 ms. The pure-MLX tier alone remains fastest among the CPU-comparable backends on most 25-qubit workloads. Across the full 29-workload suite, the shader tier accelerates 26 workloads by up to 25× over pure MLX. The same architecture supports reproducible benchmark artifacts (CSV/JSON), OpenQASM 2.0 circuit import, and broad algorithm coverage across VQE, QAOA, QCBM, QFT, Grover, and time-evolution workflows.
Reliability is built into the stack: the framework is validated with 234 regression tests and benchmark alignment against widely used suites and ecosystems, including QASMBench, PennyLane, Yao.jl, and Qulacs. The website experience you are viewing is the product-facing layer over that same technical foundation.
Key technical points from the Qupertino technical report, translated into practical product guidance for users.
Apple Silicon is not a discrete GPU workflow. CPU and GPU share one physical memory pool, so state vectors can stay resident without explicit host-device transfers. This reduces orchestration overhead and improves interactive iteration for many NISQ-era workloads.
MLX is widely used for ML workloads, but there is currently no native MLX quantum simulator runtime. Qupertino addresses that gap by providing a local state-vector simulator stack, gate libraries, algorithm modules, and benchmark tooling in one desktop workflow.
The benchmark families follow community baselines and algorithm classes used in research practice: QASMBench/OpenQASM circuits, QFT/phase estimation, variational methods (VQE/QAOA/QCBM), Grover search, and Hamiltonian simulation via Trotter-Suzuki decomposition.
Runs generate structured artifacts with consistent timing outputs and machine-readable exports. The goal is not just raw speed, but repeatable experiment bookkeeping for publication, classroom use, and cross-framework comparison.
The paper reports 235 validation tests spanning gate correctness, parser behavior, algorithm outputs, and tutorial-backed educational examples.
Regression coverage includes gate operations, state preparation, algorithm-level checks, and framework parity validations.
Parser and execution coverage includes single-, two-, and three-qubit gate families with user-defined gate inlining and practical benchmark circuit compatibility.
Benchmark families are aligned with widely used ecosystems (PennyLane, Yao.jl, Qulacs, QuantumToolbox.jl, QASMBench) for stronger external comparability.
Timing outputs and benchmark summaries are emitted as machine-readable CSV/JSON artifacts for independent reruns and publication appendices.
Complex64 state vectors scale from 8 MB at 20 qubits to 256 MB at 25 qubits, 8 GB at 30 qubits, and 256 GB at 35 qubits.
Benchmark orchestration, queueing, logs, and output review run locally on macOS, minimizing external dependencies during experiment cycles.
Current desktop snapshots from a complete local workflow: benchmark selection, run orchestration, live logs, and export-ready outputs.
This gallery maps directly to the research workflow described in the paper: define workload families, launch runs with fixed parameters, monitor state-vector execution on Apple Silicon, and collect comparable artifacts for analysis.
Instead of isolated screenshots, read this section as one continuous pipeline from circuit definition to reproducible report output.
Comprehensive benchmark coverage including standard OpenQASM workloads, variational algorithms, and time-evolution simulations.
Reproduces OpenQASM workloads across chemistry, optimization, arithmetic, and ML circuits.
Fourier primitives validated against analytical transforms and reference-style benchmark data.
VQE, QAOA, and QCBM with hardware-efficient ansatze and optimization loops.
Trotter-Suzuki Hamiltonian simulation (including Ising/Heisenberg-style model workloads).
| Benchmark | Representative Data | Scope | Notes |
|---|---|---|---|
| Random Circuit | 22q: 2.45s • 23q: 5.16s • 25q: 22.40s | M-series runs | State-vector scaling snapshot |
| Variational (HE ansatz) | 22q: 2.11s • 23q: 4.44s • 25q: 19.24s | VQE / QAOA / QCBM family | Hardware-efficient ansatz profile |
| Grover Search | 21q: 1.82s • 22q: 5.00s • 24q: 40.08s | Oracle + amplitude amplification | Rapid growth at higher qubits |
| Coverage | QASMBench, QFT, phase estimation, variational, Hamiltonian, Grover | OpenQASM + custom circuits | Designed for reproducible studies |
| Validation | 251 executable tests | Correctness and regression checks | Includes educational QIT verification appendix |
Qupertino ships a broad gallery of runnable examples: 21 parameterized benchmark families (any qubit count) plus a
42-circuit OpenQASM corpus. Run a benchmark family with
./bench.sh --circuit <key>, or execute any QASM circuit through the QASM suite.
For the full 250+ example catalog (gate algebra, algorithm identities, MPS parity, backend/MCP API),
see the Examples & Catalog page.
--circuit <key>| Category | Circuit keys |
|---|---|
| Spin & Hamiltonian dynamics | hamiltonian_simulation, time_evolution, trotter, steady_state, heisenberg, heisenberg_xxz, heisenberg_random_field, tfim, tfim_trotter2, tfim_random_field, long_range_ising, ladder_heisenberg |
| Variational & QML | qcbm, qaoa, vqe, variational_circuit |
| Core algorithms | qft, phase_estimation, grover, ghz, random_circuit |
datasets/qasm/local/ — 42 circuits| Category | Circuit (qubits) |
|---|---|
| States & entanglement | bell (2), bell_state (2), bell_n4 (4), ghz_state_n23 (23), cat_state_n22 (22), wstate_n3 (3), wstate_n27 (27), coin_flip (1), qrng_n4 (4) |
| Textbook algorithms | deutsch_n2 (2), grover_n2 (2), grover_2qubit (2), qft_n4 (4), qft_n18 (18), inverseqft_n4 (4), qpe_n9 (9), ipea_n2 (2), swap_test_n25 (25), toffoli_n3 (3), teleport_minimal (3), teleportation_n3 (3), bv_n14 Bernstein–Vazirani (14), hs4_n4 hidden shift (4), bwt_n21 binary welded tree (21) |
| Arithmetic & factoring | bigadder_n18 (18), multiplier_n15 (15), multiply_n13 (13), qf21_n15 factor 21 (15), factor247_n15 factor 247 (15) |
| Variational & physics | vqe_n4 (4), vqe_n24 (24), vqe_ising, variational_n4 (4), ising_n10 (10), ising_n26 (26) |
| Applied, ML & QEC | dnn_n16 quantum DNN (16), knn_n25 quantum kNN (25), sat_n11 SAT (11), seca_n11 (11), qram_n20 QRAM (20), qec9xz_n17 Shor [[9,1,3]] code (17), advanced_circuit |
Build circuits, launch parameter sweeps, and inspect noise behavior without sending data off your machine. Every phase of experimentation remains local by default.
Qupertino is built for Apple Silicon unified memory. Because there is currently no native MLX quantum simulator, Qupertino provides the local state-vector layer and workflow tooling directly in the app. It supports QFT, QAOA, QCBM, Grover, Hamiltonian simulation, and OpenQASM 2.0 import with reproducible artifacts validated by 150+ executable tests.
Per-family scaling exports for the pure-MLX tier. The headline four-backend comparison and the Metal shader speedups are in the Performance section above.
Qupertino is free and open source under the MIT License. Both the source code and the macOS binaries are free to use, modify, and redistribute — no purchase or license key required.
This is an early alpha version intended for testing and development. Features may be incomplete, unstable, or change significantly before the stable release. Please report any issues on GitHub.
This macOS build is not signed by Apple. Remove the quarantine attribute in Terminal before first launch:
# If installed to /Applications (system-wide):
xattr -d com.apple.quarantine /Applications/QuantumStudio.app
# If installed to ~/Applications (user-only):
xattr -d com.apple.quarantine ~/Applications/QuantumStudio.appWhy? macOS quarantines downloaded apps. For unsigned apps, Gatekeeper may block execution until this flag is removed.
Core simulation runs locally on your Mac. Internet is only needed for things like downloads, purchases, or visiting external resources.
No. There is currently no native MLX quantum simulator shipped as a platform runtime, which is why Qupertino includes its own local simulator stack.