QuipNetwork/xquadPublic

A hardware-agnostic SDK for optimization problems: define a problem once, then lower it to any quantum or classical solver

AI summary: A decentralized protocol enabling cross-chain quadratic funding and verifiable credential voting for Web3.

Stars
5.6K
+1 today
Forks
17
Watchers
6
Open issues
1
Open PRs
0
Contributors
~5
Commits
829
Branches
7

PythonAGPL-3.0Created Apr 2, 2026Last push 4d agoLatest release v0.5.2+4 this month

Quick answers

What is xquad?
A decentralized protocol enabling cross-chain quadratic funding and verifiable credential voting for Web3.
What does xquad do?
XQuad functions as a universal intermediate representation and toolchain for quadratic optimization problems, bridging the gap between quantum annealers and classical solvers. It provides a highly specified virtual machine architecture, akin to LLVM for quadratic models, allowing developers to write an optimization problem once and target any supported backend. The project includes a robust Rust core designed to be embeddable in constrained environments, alongside Python distributions for broader accessibility. By enforcing strict parity between the Rust production VM and the Python reference VM, it ensures absolute reliability across diverse hardware targets.
Who is xquad for?
Quantum computing researchers, data scientists, and systems engineers working on advanced optimization problems across diverse hardware platforms. Familiarity with constraint-programming workflows is highly recommended for optimal usage.
How do I get started with xquad?
Review the specification in spec/xqvm/SPEC.md and explore the Rust crates or Python distributions.
How popular is xquad on GitHub?
QuipNetwork/xquad has 5,585 stars and 17 forks on GitHub.
What license does xquad use?
QuipNetwork/xquad is released under the AGPL-3.0 license.

Star history

since Jul 28, 2026
02K4KJul 2026Sep 2026Oct 2026Nov 2026
5.6K stars as of Nov 17, 2026. Measured daily since Jul 28, 2026; GitHub no longer exposes earlier star timestamps.

Update history

3 recorded
  • Nov 14, 2026New release v0.5.2 (previously v0.4.5).
  • Oct 16, 2026Description changed from "A rust implementation of the Quip Network's quantum virtual machine." to "A hardware-agnostic SDK for optimization problems: define a problem once, then lower it to any quantum or classical solv".
  • Oct 4, 2026Previously tracked as QuipNetwork/xq-rs; its 1 daily snapshot and 1 trending appearance were merged into this profile. Stars: 5,596 on 2026-07-28 under the old name, 5,585 on 2026-10-04 (-11).

Contribution activity

commits per day, last 52 weeks
NovDecJanFebMarAprMayJunJulAugSepOctNovMonWedFri2025-11-16: 0 commits2025-11-17: 0 commits2025-11-18: 0 commits2025-11-19: 0 commits2025-11-20: 0 commits2025-11-21: 0 commits2025-11-22: 0 commits2025-11-23: 0 commits2025-11-24: 0 commits2025-11-25: 0 commits2025-11-26: 0 commits2025-11-27: 0 commits2025-11-28: 0 commits2025-11-29: 0 commits2025-11-30: 0 commits2025-12-01: 0 commits2025-12-02: 0 commits2025-12-03: 0 commits2025-12-04: 0 commits2025-12-05: 0 commits2025-12-06: 0 commits2025-12-07: 0 commits2025-12-08: 0 commits2025-12-09: 0 commits2025-12-10: 0 commits2025-12-11: 0 commits2025-12-12: 0 commits2025-12-13: 0 commits2025-12-14: 0 commits2025-12-15: 0 commits2025-12-16: 0 commits2025-12-17: 0 commits2025-12-18: 0 commits2025-12-19: 0 commits2025-12-20: 0 commits2025-12-21: 0 commits2025-12-22: 0 commits2025-12-23: 0 commits2025-12-24: 0 commits2025-12-25: 0 commits2025-12-26: 0 commits2025-12-27: 0 commits2025-12-28: 0 commits2025-12-29: 0 commits2025-12-30: 0 commits2025-12-31: 0 commits2026-01-01: 0 commits2026-01-02: 0 commits2026-01-03: 0 commits2026-01-04: 0 commits2026-01-05: 0 commits2026-01-06: 0 commits2026-01-07: 0 commits2026-01-08: 0 commits2026-01-09: 0 commits2026-01-10: 0 commits2026-01-11: 0 commits2026-01-12: 0 commits2026-01-13: 0 commits2026-01-14: 0 commits2026-01-15: 0 commits2026-01-16: 0 commits2026-01-17: 0 commits2026-01-18: 0 commits2026-01-19: 0 commits2026-01-20: 0 commits2026-01-21: 0 commits2026-01-22: 0 commits2026-01-23: 0 commits2026-01-24: 0 commits2026-01-25: 0 commits2026-01-26: 0 commits2026-01-27: 0 commits2026-01-28: 0 commits2026-01-29: 0 commits2026-01-30: 0 commits2026-01-31: 0 commits2026-02-01: 0 commits2026-02-02: 0 commits2026-02-03: 0 commits2026-02-04: 0 commits2026-02-05: 0 commits2026-02-06: 0 commits2026-02-07: 0 commits2026-02-08: 0 commits2026-02-09: 0 commits2026-02-10: 0 commits2026-02-11: 0 commits2026-02-12: 0 commits2026-02-13: 0 commits2026-02-14: 0 commits2026-02-15: 0 commits2026-02-16: 0 commits2026-02-17: 0 commits2026-02-18: 0 commits2026-02-19: 0 commits2026-02-20: 0 commits2026-02-21: 0 commits2026-02-22: 0 commits2026-02-23: 0 commits2026-02-24: 0 commits2026-02-25: 0 commits2026-02-26: 0 commits2026-02-27: 0 commits2026-02-28: 0 commits2026-03-01: 0 commits2026-03-02: 0 commits2026-03-03: 0 commits2026-03-04: 0 commits2026-03-05: 0 commits2026-03-06: 0 commits2026-03-07: 0 commits2026-03-08: 0 commits2026-03-09: 0 commits2026-03-10: 0 commits2026-03-11: 27 commits2026-03-12: 0 commits2026-03-13: 11 commits2026-03-14: 13 commits2026-03-15: 14 commits2026-03-16: 2 commits2026-03-17: 2 commits2026-03-18: 0 commits2026-03-19: 0 commits2026-03-20: 0 commits2026-03-21: 0 commits2026-03-22: 0 commits2026-03-23: 8 commits2026-03-24: 0 commits2026-03-25: 2 commits2026-03-26: 1 commit2026-03-27: 20 commits2026-03-28: 0 commits2026-03-29: 0 commits2026-03-30: 0 commits2026-03-31: 0 commits2026-04-01: 1 commit2026-04-02: 1 commit2026-04-03: 0 commits2026-04-04: 0 commits2026-04-05: 0 commits2026-04-06: 0 commits2026-04-07: 0 commits2026-04-08: 3 commits2026-04-09: 0 commits2026-04-10: 0 commits2026-04-11: 0 commits2026-04-12: 0 commits2026-04-13: 11 commits2026-04-14: 0 commits2026-04-15: 5 commits2026-04-16: 2 commits2026-04-17: 1 commit2026-04-18: 0 commits2026-04-19: 0 commits2026-04-20: 1 commit2026-04-21: 0 commits2026-04-22: 1 commit2026-04-23: 0 commits2026-04-24: 7 commits2026-04-25: 0 commits2026-04-26: 0 commits2026-04-27: 3 commits2026-04-28: 2 commits2026-04-29: 2 commits2026-04-30: 1 commit2026-05-01: 0 commits2026-05-02: 0 commits2026-05-03: 0 commits2026-05-04: 0 commits2026-05-05: 5 commits2026-05-06: 0 commits2026-05-07: 0 commits2026-05-08: 0 commits2026-05-09: 0 commits2026-05-10: 0 commits2026-05-11: 0 commits2026-05-12: 0 commits2026-05-13: 0 commits2026-05-14: 1 commit2026-05-15: 0 commits2026-05-16: 0 commits2026-05-17: 2 commits2026-05-18: 0 commits2026-05-19: 0 commits2026-05-20: 0 commits2026-05-21: 0 commits2026-05-22: 1 commit2026-05-23: 0 commits2026-05-24: 0 commits2026-05-25: 4 commits2026-05-26: 1 commit2026-05-27: 3 commits2026-05-28: 0 commits2026-05-29: 0 commits2026-05-30: 0 commits2026-05-31: 0 commits2026-06-01: 1 commit2026-06-02: 2 commits2026-06-03: 1 commit2026-06-04: 0 commits2026-06-05: 0 commits2026-06-06: 0 commits2026-06-07: 1 commit2026-06-08: 1 commit2026-06-09: 1 commit2026-06-10: 3 commits2026-06-11: 1 commit2026-06-12: 0 commits2026-06-13: 0 commits2026-06-14: 0 commits2026-06-15: 0 commits2026-06-16: 0 commits2026-06-17: 0 commits2026-06-18: 0 commits2026-06-19: 0 commits2026-06-20: 0 commits2026-06-21: 1 commit2026-06-22: 0 commits2026-06-23: 0 commits2026-06-24: 0 commits2026-06-25: 0 commits2026-06-26: 0 commits2026-06-27: 0 commits2026-06-28: 0 commits2026-06-29: 0 commits2026-06-30: 0 commits2026-07-01: 0 commits2026-07-02: 0 commits2026-07-03: 0 commits2026-07-04: 0 commits2026-07-05: 0 commits2026-07-06: 0 commits2026-07-07: 0 commits2026-07-08: 1 commit2026-07-09: 0 commits2026-07-10: 1 commit2026-07-11: 0 commits2026-07-12: 0 commits2026-07-13: 1 commit2026-07-14: 2 commits2026-07-15: 2 commits2026-07-16: 0 commits2026-07-17: 0 commits2026-07-18: 0 commits2026-07-19: 0 commits2026-07-20: 4 commits2026-07-21: 0 commits2026-07-22: 2 commits2026-07-23: 0 commits2026-07-24: 1 commit2026-07-25: 0 commits2026-07-26: 0 commits2026-07-27: 0 commits2026-07-28: 0 commits2026-07-29: 0 commits2026-07-30: 0 commits2026-07-31: 0 commits2026-08-01: 0 commits2026-08-02: 0 commits2026-08-03: 0 commits2026-08-04: 0 commits2026-08-05: 0 commits2026-08-06: 0 commits2026-08-07: 0 commits2026-08-08: 0 commits2026-08-09: 1 commit2026-08-10: 0 commits2026-08-11: 0 commits2026-08-12: 3 commits2026-08-13: 3 commits2026-08-14: 0 commits2026-08-15: 0 commits2026-08-16: 0 commits2026-08-17: 0 commits2026-08-18: 4 commits2026-08-19: 0 commits2026-08-20: 0 commits2026-08-21: 17 commits2026-08-22: 2 commits2026-08-23: 0 commits2026-08-24: 1 commit2026-08-25: 3 commits2026-08-26: 1 commit2026-08-27: 3 commits2026-08-28: 3 commits2026-08-29: 0 commits2026-08-30: 0 commits2026-08-31: 1 commit2026-09-01: 0 commits2026-09-02: 0 commits2026-09-03: 2 commits2026-09-04: 2 commits2026-09-05: 0 commits2026-09-06: 0 commits2026-09-07: 0 commits2026-09-08: 1 commit2026-09-09: 2 commits2026-09-10: 3 commits2026-09-11: 4 commits2026-09-12: 1 commit2026-09-13: 0 commits2026-09-14: 1 commit2026-09-15: 2 commits2026-09-16: 0 commits2026-09-17: 0 commits2026-09-18: 1 commit2026-09-19: 1 commit2026-09-20: 0 commits2026-09-21: 2 commits2026-09-22: 0 commits2026-09-23: 23 commits2026-09-24: 20 commits2026-09-25: 32 commits2026-09-26: 0 commits2026-09-27: 0 commits2026-09-28: 27 commits2026-09-29: 16 commits2026-09-30: 11 commits2026-10-01: 0 commits2026-10-02: 0 commits2026-10-03: 0 commits2026-10-04: 0 commits2026-10-05: 5 commits2026-10-06: 16 commits2026-10-07: 14 commits2026-10-08: 4 commits2026-10-09: 0 commits2026-10-10: 0 commits2026-10-11: 6 commits2026-10-12: 40 commits2026-10-13: 22 commits2026-10-14: 6 commits2026-10-15: 7 commits2026-10-16: 0 commits2026-10-17: 0 commits2026-10-18: 0 commits2026-10-19: 0 commits2026-10-20: 14 commits2026-10-21: 12 commits2026-10-22: 20 commits2026-10-23: 7 commits2026-10-24: 8 commits2026-10-25: 0 commits2026-10-26: 10 commits2026-10-27: 6 commits2026-10-28: 0 commits2026-10-29: 0 commits2026-10-30: 4 commits2026-10-31: 0 commits2026-11-01: 0 commits2026-11-02: 0 commits2026-11-03: 1 commit2026-11-04: 7 commits2026-11-05: 4 commits2026-11-06: 6 commits2026-11-07: 1 commit2026-11-08: 0 commits2026-11-09: 2 commits2026-11-10: 0 commits2026-11-11: 0 commits2026-11-12: 0 commits2026-11-13: 0 commits2026-11-14: 0 commits
599 commits in the last yearLessMore

Signals and awards

derived from tracked data
  • Very active

    599 commits in 52 weeks

  • Continuous integration

    Automated checks passing

What xquad does

XQuad functions as a universal intermediate representation and toolchain for quadratic optimization problems, bridging the gap between quantum annealers and classical solvers. It provides a highly specified virtual machine architecture, akin to LLVM for quadratic models, allowing developers to write an optimization problem once and target any supported backend. The project includes a robust Rust core designed to be embeddable in constrained environments, alongside Python distributions for broader accessibility. By enforcing strict parity between the Rust production VM and the Python reference VM, it ensures absolute reliability across diverse hardware targets.

Quantum computing researchers, data scientists, and systems engineers working on advanced optimization problems across diverse hardware platforms. Familiarity with constraint-programming workflows is highly recommended for optimal usage.

  • Hardware-agnostic compilation: Translates quadratic optimization problems into a common intermediate representation suitable for varied hardware targets.
  • Strict specification enforcement: Ensures absolute behavioral parity between the Rust production VM and Python reference VM via continuous integration.
  • Embeddable Rust core: Designed with no_std support, allowing the virtual machine to be deployed in highly constrained environments.
  • Multi-language ecosystem: Ships as an integrated suite of Rust crates and Python distributions to support a wide range of scientific developers.
  • Quantum and classical backend support: Allows execution on both cutting-edge quantum annealers and traditional classical compute solvers.

Where teams use it

Algorithm development

Researchers develop and test complex quadratic optimization algorithms in Python before compiling them for high-performance quantum hardware.

Hardware benchmarking

Data scientists use the common intermediate representation to run the exact same optimization problem across classical and quantum solvers for performance comparison.

Embedded optimization

Engineers deploy the lightweight Rust core into edge devices to perform local optimization tasks without relying on external cloud compute.

Cross-platform research

Academic teams utilize the toolchain to guarantee their optimization models behave identically regardless of the underlying execution environment.

Getting started: Review the specification in spec/xqvm/SPEC.md and explore the Rust crates or Python distributions.

README

main branch

XQuad

Early public release. The instruction set, binary format, and public API may still change before v1.0. Production use is not recommended yet.

XQuad is a hardware-agnostic toolchain for expressing and running quadratic optimization problems (QUBO / Ising / integer) across quantum annealers and classical solvers. It ships as two Rust crates plus four Python distributions built around a single virtual-machine specification.

Think of it as LLVM for quadratic models -- a common intermediate representation that lets you write a problem once and retarget it to any supported backend.

  • Spec-first. Every behaviour is nailed down in spec/xqvm/SPEC.md and the VM is mechanically held to it: every committed conformance vector runs xqvm in CI against the outcome the spec prescribes, and a mismatch fails the build.
  • Embeddable. The Rust core supports no_std + alloc, so the same VM runs inside WASM runtimes, Substrate pallets, and native binaries.
  • Interactive. The Python umbrella (xquad) is REPL and Jupyter-friendly: load a program once, run it with different calldata, inspect outputs by slot. Low-level FFI lives in xqffi; user-facing Program / Session / RunResult live in xquad.program.

Install

Python (from PyPI)

Install XQuad into a project environment first: a virtual environment, or a uv project.

python -m venv .venv && source .venv/bin/activate
pip install xquad
# or, in a uv project:
uv add xquad

For the xquad command alone, outside any project, install it as a uv tool, with the quip extra for the xquad quip commands:

uv tool install xquad            # the xquad command
uv tool install 'xquad[quip]'    # with the xquad quip commands

On macOS, a user install (pip install --user, or pip falling back to one) puts the xquad command in ~/Library/Python/3.x/bin, which is not on PATH; python -m xquad runs the same command without it.

The xquad package is the umbrella: the full pipeline and the xquad command. To pick individual pieces instead, install xqffi, xqcp and xqsa (FFI bindings, DSL, solvers). Prebuilt wheels are available for Linux x86_64 and aarch64 (CPython >= 3.13). On macOS and Windows, pip builds the xqffi Rust extension from source -- this requires a Rust toolchain (>= 1.85).

GPU/QPU support

The base install includes CPU simulated annealing only. To use GPU or quantum hardware solvers, install the corresponding extra:

Solver Install Prerequisite
NVIDIA CUDA GPU (cuda) pip install 'xquad[cuda]' CUDA 12.x driver + NVIDIA GPU
Apple Metal GPU (metal) pip install 'xquad[metal]' Apple Silicon Mac with a Metal device
D-Wave Advantage QPU (dwave) pip install 'xquad[dwave]' D-Wave Leap account + API token
Quip Network solver (quip) pip install 'xquad[quip]' QUIP_RPC_URL + a configured signer

Extras are composable: pip install 'xquad[cuda,dwave]'. See xqsa/README.md for driver prerequisites and per-solver quick-starts.

For a guided walkthrough that installs XQuad, verifies it, and runs a complete problem end to end, see Install XQuad in the book.

Package map

Two Rust crates on crates.io:

Crate Description
xqvm X-Quadratic Virtual Machine interpreter, bytecode codec, opcode table (no_std + alloc)
xqasm .xqasm text-format assembler

Four Python distributions on PyPI:

Package Description
xqffi PyO3 FFI bindings for xqvm + xqasm (xqffi.vm, xqffi.asm, xqffi.verifier)
xqcp Constraint-programming DSL that compiles to .xqasm
xqsa Solver adapters -- CPU/GPU annealers, D-Wave QPU, Quip network
xquad Umbrella meta-package with interactive Program / Session / RunResult API, and the xquad CLI (xquad vm asm / dis / run / check)

The one Rust package without a crates.io artefact is the xqffi pyo3 crate itself -- it ships as the xqffi PyPI wheel rather than a reusable Rust library.

Quick start

A minimal program (CLI)

; add.xqasm -- push two integers and add them
PUSH 10
PUSH 32
ADD
HALT
xquad vm asm add.xqasm -o add.xqb && xquad vm run add.xqb

End-to-end (Python, via the umbrella)

The recommended user-facing surface is xquad.program.Program + Session + RunResult. Load once, run many times with different calldata, inspect outputs by slot:

from xquad.program import Program

program = Program.from_source("""
PUSH 0
INPUT r0
PUSH 1
INPUT r1
LOAD r0
LOAD r1
ADD
STOW r2
PUSH 0
OUTPUT r2
HALT
""")

session = program.session(output_slots=1)
session.set_calldata([40, 2])
result = session.run()
assert dict(result.outputs) == {0: 42}

Program.load(bytes) takes wire-format bytecode; Session.run() returns a RunResult with dict-keyed outputs (unset slots present as None), residual stack, and step count. See Running Programs for the full tour.

Low-level / conformance surface

For conformance harnesses and one-shot execution, the raw xqffi.vm.Vm is still available directly:

from xqffi.asm import assemble_source
from xqffi.vm import Vm

bytecode = assemble_source(src)
v = Vm()
v.set_calldata([40, 2])
v.set_output_slots(1)
v.run(bytecode)
assert v.outputs() == [42]

The xquad.vm.VM class offers a middle tier -- a wrapper around the Rust VM that accepts .xqasm source, keeps calldata, output slots and limits across runs, and hands back the xqffi types unchanged.

End-to-end worked example

examples/tsp/ shows a full Travelling Salesman Problem driven from the xqcp DSL through the VM and xqsa solver:

uv run python examples/tsp/runner.py --seed 42
uv run python examples/maxcut/runner.py --seed 42

# Run every example and check each finds a valid solution:
make example-smoke

Architecture

XQuad is a stack-based interpreter with a 256-slot register file. Registers hold typed values -- integers, integer vectors, QUBO/Ising models (XqmxModel), and candidate solutions (XqmxSample). A dedicated loop stack drives RANGE/ITER iteration.

The opcode table is declared once in xqvm/src/bytecode/types/table.rs via the opcodes! x-macro; xqvm/opcodes.yaml is the machine-readable mirror, compared with the Rust macro at compile time (xqvm/src/bytecode/types/parity.rs), so the two cannot drift.

The binary format (.xqb) opens with a fixed 15-byte XQBC header -- magic, version, calldata/output-slot counts, code length, and a CRC-32 checksum of the payload -- followed by the instruction stream: an opcode byte followed by its operands in big-endian byte order.

See docs/book/src/xqvm/opcodes.md for the opcode reference and spec/xqvm/SPEC.md for the normative spec.

Development

Prerequisites

curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh   # stable Rust
make deps                                                          # dev tools

Local setup

make xquad

This syncs the Python workspace (xqcp, xqsa, xqffi, xquad) into .venv/, builds the xqffi pyo3 extension via maturin, puts the repo root on sys.path so scripts anywhere in the repo can import xqcp / xqsa / xqffi / xquad naturally, and installs the xquad command into .venv/bin/, run with uv run xquad.

Open a REPL with everything ready:

make repl

CI-equivalent locally

make preflight    # what CI enforces, split into preflight-rs / -py / -docs / -policy
make conformance  # the specification vectors under xqvm/tests/vectors/

Contributing

See CONTRIBUTING.md for the development workflow, commit conventions, and DCO sign-off requirements. Agent guidelines for AI coding assistants are in AGENTS.md; cutting a release is documented in RELEASING.md.

License

Licensed under the GNU Affero General Public License v3.0 or later.

View on GitHub

Recent activity

commits and pull requests

Recent open issues

view all

Releases and announcements

15 total
  1. v0.5.2v0.5.2Nov 9, 2026

    SolverQuip now survives a dropped connection to a Quip TestNet node. A node or proxy can close an idle websocket after a couple of minutes, and before this release the next chain read failed with a raw transport error. Reads now reconnect, check that the node still serves the same chain, and try again once. ### Behaviour changes - Chain reads that hit a dropped connection reconnect and retry once. If the retry fails, they raise `QuipConnectionError`, as the receipt methods document, instead of a raw `JSONDecodeError`, `WebSocketException` or `OSError`. - A connection lost while submitting raises `QuipSubmissionError`, saying the outcome is unknown, because the extrinsic may already be on chain. Before, it surfaced as a raw `JSONDecodeError` or `BrokenPipeError`. - A genesis mismatch stops at once with `GenesisMismatch`, also when found on a reconnect or at a finality deadline. Before, it was retried as a plain connection error or reported as a finality stall. - The `quip` extra now requires `substrate-interface>=1.8.0` (was `>=1.7.4`) and lists `websocket-client>=0.57.0,<2` directly. On 1.7.x every read after a drop raised `AttributeError`. ### Packages | Registry | Packages |

  2. v0.5.1v0.5.1Nov 4, 2026

    v0.5.1 corrects what v0.5.0 says about itself. Deprecated names keep working through 0.5.x and now say they are removed in v0.6.0, the book pages that described the removed Python VM now describe the Rust VM, and a new guide covers migrating from 0.4 to 0.5. No API, bytecode, VM behaviour or CLI flag changes. ### Highlights - [Migrating from 0.4 to 0.5](https://developers.quip.network/docs/xquad/appendix/migration-0.5.html) lists each breaking change in 0.5.0 as old to new: the Python VM and its types, the typed `xqffi` model API, `xqcp` domains, the solver classes, registry and metadata, custom `Solver` subclasses, and the verifier and step-metering changes. - The Running page now describes `xquad.vm.VM`: `XqmxSample` refuses an out-of-domain value, `run()` raises `TypeError` for an unsupported calldata element, and an out-of-domain `SETLINE` or `ADDLINE` faults with `SampleOutOfDomain`. - The Running page and the `xqffi` README name the faults the model types raise: `InvalidAllocation` and `IndexOutOfBounds`, where they said `ValueError` and `IndexError`. The energy page names `XqmxModel.energy`. ### Behaviour changes - Deprecation warnings that named v0.5.0, the `mode=` warn

  3. v0.5.0v0.5.0Oct 30, 2026

    v0.5.0 removes the Python reference VM, moves `xqsa`, `xqcp` and `xquad` onto the typed `xqffi` model API, and replaces the per-hardware solvers with one `Solver` base. Code written against 0.4 needs changes: read Breaking changes or the [migration guide](https://developers.quip.network/docs/xquad/appendix/migration-0.5.html) first. This release carries part of its planned scope, and the rest moves to v0.6.0. Install v0.5.1 rather than this release: it fixes the two known issues below and changes no API. ### Breaking changes **One VM** - The Python reference VM is gone, and `xqvm_py` has no 0.5 release: `from xqvm_py ...` → `from xqffi.vm ...` or `xquad.types`. - `VM(backend=VMBackend.RUST)` → `VM()`. `VMBackend`, the `backend` argument and the runners' `--interpreter` flag are removed. **Model types** - `xquad.types.XQMX`, `XQMXDomain`, `XQMXMode`, `Vec` and `VecElem` → `XqmxModel`, `XqmxSample` and `Domain`: `XQMX.binary_model(size=4)` → `XqmxModel.binary(4)`, and `compute_energy(model, sample)` → `model.energy(sample)`. - Exceptions change around the model types. An oversized model or an impossible grid raises `InvalidAllocation` or `InvalidGridDimensions`, where 0.4 raised

  4. v0.4.5v0.4.5Oct 26, 2026

    `pip install xquad` now installs the `xquad` command, with the XQVM tools under `xquad vm` and a new `xquad quip` group for Quip accounts, job orders and receipts. SolverQuip gains named accounts, a read-only client and a TLS context option, and every job order it sends now settles from finalized chain state. SolverQuip needs a Quip network on runtime 119 or later. ### Highlights - The `xquad` CLI ships with `pip install xquad` (or `python -m xquad`): `xquad vm asm`, `dis`, `run` and `check`, with the flags, output and exit codes of `xqcli`. - `xquad quip account list|show|new|import|use` manages named Quip accounts at project and user level; `xquad quip orders`, `status` and `reclaim` read and reclaim an account's job orders. `--json` gives machine-readable output. - SolverQuip resolves its signer through named Quip accounts, and `SolverQuip(read_only=True)` reads balances, orders and receipts without loading a key. New `balance()`, `reserved()` and `order_slots()`. - `SolverQuip(ssl_context=...)` uses your TLS context for the RPC connection and the faucet request, for example to check revocation. - `xqffi.vm.Vm.run` writes the VM's text or JSON trace to a file. ### Behaviour c

  5. v0.4.4v0.4.4Oct 20, 2026

    `SolverQuip` now shows what an order paid, both on a submitted order and on a failed one, and names accounts in SS58 form in its warnings, prompts and errors. A raw access dict that cannot be read is refused when the option is checked, instead of failing later. The book and spec drop the runtime 119 caveats. ### Highlights - A submitted order's box shows the fee it paid, and a failed order shows the fee it was charged. - The unregistered-solver warning, the autofund prompt, balance errors and faucet errors name accounts in SS58 form. Display falls back to hex when the chain's SS58 format is unknown. - An unreadable raw access dict raises `QuipOrderOptionError("access")`: at construction for a client default, per order otherwise. - The book notes that SolverQuip's TLS clients do not check certificate revocation, and how to fail closed. ### Behaviour changes - Messages that named an account in hex now use SS58. Code that parses these messages needs updating. - The refusal to reclaim an answered order now reads "awaits a claim" rather than "awaits the winner's claim". ### Packages | Registry | Packages | | --- | --- | | crates.io | [xqvm](https://crates.io/crates/xqvm/0.4.4) · [

Code frequency

additions and deletions
+35.6K-35.6KWeek of 2026-03-08: +11,330 linesWeek of 2026-03-08: -676 linesWeek of 2026-03-15: +2,827 linesWeek of 2026-03-15: -1,632 linesWeek of 2026-03-22: +8,234 linesWeek of 2026-03-22: -3,020 linesWeek of 2026-03-29: +25 linesWeek of 2026-03-29: -17 linesWeek of 2026-04-05: +2,681 linesWeek of 2026-04-05: -9 linesWeek of 2026-04-12: +15,576 linesWeek of 2026-04-12: -14,408 linesWeek of 2026-04-19: +35,573 linesWeek of 2026-04-19: -16,184 linesWeek of 2026-04-26: +3,301 linesWeek of 2026-04-26: -877 linesWeek of 2026-05-03: +4,383 linesWeek of 2026-05-03: -130 linesWeek of 2026-05-10: +3,074 linesWeek of 2026-05-10: -215 linesWeek of 2026-05-17: +4,522 linesWeek of 2026-05-17: -1,826 linesWeek of 2026-05-24: +2,213 linesWeek of 2026-05-24: -668 linesWeek of 2026-05-31: +6,542 linesWeek of 2026-05-31: -70 linesWeek of 2026-06-07: +4,017 linesWeek of 2026-06-07: -583 linesWeek of 2026-06-14: +0 linesWeek of 2026-06-14: -0 linesWeek of 2026-06-21: +4,564 linesWeek of 2026-06-21: -0 linesWeek of 2026-06-28: +0 linesWeek of 2026-06-28: -0 linesWeek of 2026-07-05: +6,008 linesWeek of 2026-07-05: -110 linesWeek of 2026-07-12: +3,532 linesWeek of 2026-07-12: -44 linesWeek of 2026-07-19: +4,389 linesWeek of 2026-07-19: -237 linesWeek of 2026-07-26: +0 linesWeek of 2026-07-26: -0 linesWeek of 2026-08-02: +0 linesWeek of 2026-08-02: -0 linesWeek of 2026-08-09: +26,545 linesWeek of 2026-08-09: -14,219 linesWeek of 2026-08-16: +6,444 linesWeek of 2026-08-16: -1,310 linesWeek of 2026-08-23: +17,746 linesWeek of 2026-08-23: -1,706 linesWeek of 2026-08-30: +3,171 linesWeek of 2026-08-30: -541 linesWeek of 2026-09-06: +7,183 linesWeek of 2026-09-06: -1,010 linesWeek of 2026-09-13: +3,240 linesWeek of 2026-09-13: -868 linesWeek of 2026-09-20: +15,542 linesWeek of 2026-09-20: -9,763 linesWeek of 2026-09-27: +5,892 linesWeek of 2026-09-27: -17,074 linesWeek of 2026-10-04: +16,888 linesWeek of 2026-10-04: -10,764 linesWeek of 2026-10-11: +7,837 linesWeek of 2026-10-11: -3,056 linesWeek of 2026-10-18: +11,672 linesWeek of 2026-10-18: -5,450 linesWeek of 2026-10-25: +2,597 linesWeek of 2026-10-25: -1,202 linesWeek of 2026-11-01: +1,163 linesWeek of 2026-11-01: -258 linesWeek of 2026-11-08: +48 linesWeek of 2026-11-08: -48 linesMar 8, 2026Nov 8, 2026
+248.8K lines added, -108K removed over the last year.

Commits per week

last 52 weeks
810Week of 2025-11-16: 0 commitsWeek of 2025-11-23: 0 commitsWeek of 2025-11-30: 0 commitsWeek of 2025-12-07: 0 commitsWeek of 2025-12-14: 0 commitsWeek of 2025-12-21: 0 commitsWeek of 2025-12-28: 0 commitsWeek of 2026-01-04: 0 commitsWeek of 2026-01-11: 0 commitsWeek of 2026-01-18: 0 commitsWeek of 2026-01-25: 0 commitsWeek of 2026-02-01: 0 commitsWeek of 2026-02-08: 0 commitsWeek of 2026-02-15: 0 commitsWeek of 2026-02-22: 0 commitsWeek of 2026-03-01: 0 commitsWeek of 2026-03-08: 51 commitsWeek of 2026-03-15: 18 commitsWeek of 2026-03-22: 31 commitsWeek of 2026-03-29: 2 commitsWeek of 2026-04-05: 3 commitsWeek of 2026-04-12: 19 commitsWeek of 2026-04-19: 9 commitsWeek of 2026-04-26: 8 commitsWeek of 2026-05-03: 5 commitsWeek of 2026-05-10: 1 commitsWeek of 2026-05-17: 3 commitsWeek of 2026-05-24: 8 commitsWeek of 2026-05-31: 4 commitsWeek of 2026-06-07: 7 commitsWeek of 2026-06-14: 0 commitsWeek of 2026-06-21: 1 commitsWeek of 2026-06-28: 0 commitsWeek of 2026-07-05: 2 commitsWeek of 2026-07-12: 5 commitsWeek of 2026-07-19: 7 commitsWeek of 2026-07-26: 0 commitsWeek of 2026-08-02: 0 commitsWeek of 2026-08-09: 7 commitsWeek of 2026-08-16: 23 commitsWeek of 2026-08-23: 11 commitsWeek of 2026-08-30: 5 commitsWeek of 2026-09-06: 11 commitsWeek of 2026-09-13: 5 commitsWeek of 2026-09-20: 77 commitsWeek of 2026-09-27: 54 commitsWeek of 2026-10-04: 39 commitsWeek of 2026-10-11: 81 commitsWeek of 2026-10-18: 61 commitsWeek of 2026-10-25: 20 commitsWeek of 2026-11-01: 19 commitsWeek of 2026-11-08: 2 commitsNov 16, 2025Nov 8, 2026
599 commits in the last 52 weeks.

When work happens

weekday and hour
SunMonTueWedThuFriSat036912151821Sun 0:00 — 1 commitsSun 1:00 — 0 commitsSun 2:00 — 0 commitsSun 3:00 — 0 commitsSun 4:00 — 0 commitsSun 5:00 — 0 commitsSun 6:00 — 0 commitsSun 7:00 — 0 commitsSun 8:00 — 0 commitsSun 9:00 — 0 commitsSun 10:00 — 2 commitsSun 11:00 — 5 commitsSun 12:00 — 1 commitsSun 13:00 — 1 commitsSun 14:00 — 2 commitsSun 15:00 — 5 commitsSun 16:00 — 3 commitsSun 17:00 — 2 commitsSun 18:00 — 0 commitsSun 19:00 — 0 commitsSun 20:00 — 0 commitsSun 21:00 — 0 commitsSun 22:00 — 1 commitsSun 23:00 — 2 commitsMon 0:00 — 0 commitsMon 1:00 — 2 commitsMon 2:00 — 0 commitsMon 3:00 — 7 commitsMon 4:00 — 7 commitsMon 5:00 — 4 commitsMon 6:00 — 0 commitsMon 7:00 — 0 commitsMon 8:00 — 1 commitsMon 9:00 — 2 commitsMon 10:00 — 5 commitsMon 11:00 — 2 commitsMon 12:00 — 6 commitsMon 13:00 — 4 commitsMon 14:00 — 3 commitsMon 15:00 — 15 commitsMon 16:00 — 6 commitsMon 17:00 — 7 commitsMon 18:00 — 14 commitsMon 19:00 — 11 commitsMon 20:00 — 5 commitsMon 21:00 — 5 commitsMon 22:00 — 10 commitsMon 23:00 — 9 commitsTue 0:00 — 6 commitsTue 1:00 — 5 commitsTue 2:00 — 0 commitsTue 3:00 — 0 commitsTue 4:00 — 1 commitsTue 5:00 — 0 commitsTue 6:00 — 2 commitsTue 7:00 — 2 commitsTue 8:00 — 1 commitsTue 9:00 — 0 commitsTue 10:00 — 0 commitsTue 11:00 — 4 commitsTue 12:00 — 18 commitsTue 13:00 — 6 commitsTue 14:00 — 2 commitsTue 15:00 — 6 commitsTue 16:00 — 7 commitsTue 17:00 — 11 commitsTue 18:00 — 7 commitsTue 19:00 — 8 commitsTue 20:00 — 2 commitsTue 21:00 — 8 commitsTue 22:00 — 3 commitsTue 23:00 — 1 commitsWed 0:00 — 8 commitsWed 1:00 — 6 commitsWed 2:00 — 3 commitsWed 3:00 — 7 commitsWed 4:00 — 4 commitsWed 5:00 — 1 commitsWed 6:00 — 4 commitsWed 7:00 — 5 commitsWed 8:00 — 7 commitsWed 9:00 — 0 commitsWed 10:00 — 4 commitsWed 11:00 — 4 commitsWed 12:00 — 11 commitsWed 13:00 — 10 commitsWed 14:00 — 11 commitsWed 15:00 — 7 commitsWed 16:00 — 14 commitsWed 17:00 — 8 commitsWed 18:00 — 5 commitsWed 19:00 — 2 commitsWed 20:00 — 5 commitsWed 21:00 — 1 commitsWed 22:00 — 3 commitsWed 23:00 — 2 commitsThu 0:00 — 0 commitsThu 1:00 — 0 commitsThu 2:00 — 1 commitsThu 3:00 — 0 commitsThu 4:00 — 11 commitsThu 5:00 — 3 commitsThu 6:00 — 0 commitsThu 7:00 — 0 commitsThu 8:00 — 0 commitsThu 9:00 — 1 commitsThu 10:00 — 2 commitsThu 11:00 — 3 commitsThu 12:00 — 3 commitsThu 13:00 — 2 commitsThu 14:00 — 3 commitsThu 15:00 — 7 commitsThu 16:00 — 7 commitsThu 17:00 — 3 commitsThu 18:00 — 4 commitsThu 19:00 — 4 commitsThu 20:00 — 2 commitsThu 21:00 — 15 commitsThu 22:00 — 2 commitsThu 23:00 — 0 commitsFri 0:00 — 0 commitsFri 1:00 — 0 commitsFri 2:00 — 4 commitsFri 3:00 — 2 commitsFri 4:00 — 2 commitsFri 5:00 — 0 commitsFri 6:00 — 0 commitsFri 7:00 — 1 commitsFri 8:00 — 0 commitsFri 9:00 — 3 commitsFri 10:00 — 4 commitsFri 11:00 — 3 commitsFri 12:00 — 12 commitsFri 13:00 — 3 commitsFri 14:00 — 3 commitsFri 15:00 — 11 commitsFri 16:00 — 3 commitsFri 17:00 — 12 commitsFri 18:00 — 8 commitsFri 19:00 — 10 commitsFri 20:00 — 17 commitsFri 21:00 — 4 commitsFri 22:00 — 13 commitsFri 23:00 — 3 commitsSat 0:00 — 1 commitsSat 1:00 — 4 commitsSat 2:00 — 5 commitsSat 3:00 — 0 commitsSat 4:00 — 0 commitsSat 5:00 — 0 commitsSat 6:00 — 1 commitsSat 7:00 — 0 commitsSat 8:00 — 0 commitsSat 9:00 — 0 commitsSat 10:00 — 0 commitsSat 11:00 — 0 commitsSat 12:00 — 0 commitsSat 13:00 — 0 commitsSat 14:00 — 3 commitsSat 15:00 — 1 commitsSat 16:00 — 0 commitsSat 17:00 — 0 commitsSat 18:00 — 1 commitsSat 19:00 — 6 commitsSat 20:00 — 1 commitsSat 21:00 — 2 commitsSat 22:00 — 1 commitsSat 23:00 — 0 commits
Commit volume by weekday and hour (UTC). Larger dots mean more commits.
DateListRankStars gained
Apr 10, 2026daily#14+302