qector-decoder-v3 1.0.0

Production-grade Rust/Python quantum error correction decoder. 25+ decoder families: MWPM Blossom, Union-Find (weighted), BP-OSD, Relay-BP for LDPC/qLDPC, belief-matching, colour-code, correlated two-stage matching, ambiguity clustering, CUDA/GPU batch decoding, 7-tier AutoDecoder fallback. PyMatching/Stim/Sinter/qiskit-qec compatible. Ed25519 license verification.

pip install qector-decoder-v3

QECTOR Decoder v3

Production-grade quantum error correction decoding library, Python + Rust.
Copyright © 2026 Guillaume Lessard / iD01t Productions. All Rights Reserved.

🚀 Support QECTOR Development

QECTOR is source-available and developed independently. Non-commercial use is free; sponsorship and commercial licences are what keep the decoder maintained.

Channel	Who it's for
GitHub Sponsors	Individuals and companies funding ongoing development
Commercial licence	Required for company, SaaS, OEM or funded institutional use, see COMMERCIAL.md
Direct purchase	Immediate Stripe checkout, licence issued automatically
admin@qector.store	Site licences, custom terms, academic partnerships

PyMatching-compatible MWPM validation · Belief-matching accuracy mode · BP-OSD for LDPC/qLDPC · CPU/GPU batch decoding · 7-tier self-debugging fallback engine · Ed25519 cryptographic license verification · Reproducible benchmark harness

Website · PyPI · Commercial licensing

Install

pip install qector-decoder-v3

Supported: Python 3.9-3.13 (requires-python = ">=3.9") on Linux x86_64, Windows x64, and macOS arm64.

Each release publishes 15 binary wheels: CPython 3.9/3.10/3.11/3.12/3.13 × win_amd64 / manylinux_2_17_x86_64 / macosx_11_0_arm64. There is no sdist and no aarch64, musllinux, or macOS x86_64 wheel, so pip install on any other platform will fail rather than fall back to a source build. Those targets need a local build from a licensed source checkout.

Optional extras:

pip install "qector-decoder-v3[stim]"    # Stim/Sinter/PyMatching/LDPC ecosystem
pip install "qector-decoder-v3[bench]"   # Benchmark harness (psutil, matplotlib, scipy)
pip install "qector-decoder-v3[all]"     # Full validation environment

Quick start

import numpy as np
from qector_decoder_v3 import UnionFindDecoder, BlossomDecoder

check_to_qubits = [[0, 1], [1, 2], [2, 3], [3, 4]]
n_qubits = 5
syndrome = np.array([0, 1, 0, 0], dtype=np.uint8)

fast = UnionFindDecoder(check_to_qubits, n_qubits)
print(fast.decode(syndrome))

mwpm = BlossomDecoder(check_to_qubits, n_qubits)
print(mwpm.decode(syndrome))

Batch decoding

from qector_decoder_v3 import BatchDecoder, CUDABatchDecoder

checks = [[0, 1], [1, 2], [2, 3], [3, 4]]
syndromes = np.random.randint(0, 2, size=(4096, 4), dtype=np.uint8)

cpu = BatchDecoder(checks, n_qubits=5)
corrections = cpu.parallel_batch_decode(syndromes)

if CUDABatchDecoder.is_available():
    gpu = CUDABatchDecoder(checks, n_qubits=5)
    corrections = gpu.batch_decode(syndromes)

Pass the DEM's weights to the GPU. Without edge_weights the GPU kernels run unweighted cluster growth, which cannot distinguish a p = 1e-4 mechanism from a p = 1e-2 one; on circuit-level noise that costs several times the logical error rate, no matter how fast the GPU is:

from qector_decoder_v3 import dem

model = dem.from_stim(circuit.detector_error_model(decompose_errors=True))
graph = model.collapse_to_graph()

gpu = CUDABatchDecoder(
    graph.check_to_qubits(),
    graph.num_errors,
    graph.weights().tolist(),   # log((1-p)/p) per mechanism
)

What it costs: the unweighted GPU kernels trade logical accuracy for throughput. They decode faster than the weighted CPU core, at a materially higher logical error rate that throughput does not buy back. Pass edge_weights when accuracy matters.

The weighted GPU kernel is the accuracy option: weighting restores distance scaling, at a higher per-shot cost. Both configurations are exposed for qector_cuda and qector_opencl so you can measure the trade-off on your own hardware and noise model.

No benchmark figures are published for this release. Decoder performance is hardware-, code- and noise-dependent, and any number quoted here would not describe your setup. Run the harness yourself: the JSON it writes carries its own environment and parameter block, so results are traceable to the machine that produced them. See docs/GPU_AND_CUPY.md.

AutoDecoder: 7-tier self-debugging fallback

from qector_decoder_v3 import AutoDecoder

decoder = AutoDecoder(checks, n_qubits=5)
corrections = decoder.batch_decode(syndromes)

# Inspect backend health
print(decoder._diag.backend_health)
print(decoder._diag.active_backend)

Stim workflow

import stim
from qector_decoder_v3 import BlossomDecoder
from qector_decoder_v3.stim_compat import from_stim_detector_error_model

circuit = stim.Circuit.generated(
    "surface_code:rotated_memory_z", distance=5, rounds=5,
    after_clifford_depolarization=0.005,
)
dem = circuit.detector_error_model(decompose_errors=True)
checks, n_qubits = from_stim_detector_error_model(dem)
decoder = BlossomDecoder(checks, n_qubits)

DemModel.make_decoder builds any shipped decoder family straight from the model, already carrying its weights. Enumerate them with DemModel.DECODER_KINDS:

from qector_decoder_v3 import dem

graph = dem.from_stim(circuit.detector_error_model(decompose_errors=True)).collapse_to_graph()

for kind in ("union_find", "fast_union_find", "blossom", "sparse_blossom",
             "bp_osd", "lookup_table", "hybrid_cascade", "ambiguity_cluster"):
    decoder = graph.make_decoder(kind)

# two_stage decodes the X and Z sectors separately, so it needs the sector of
# each detector -- a DEM does not record it:
#   graph.make_decoder("two_stage", check_types=[...])

BP-OSD for LDPC / qLDPC codes

from qector_decoder_v3 import codes
from qector_decoder_v3.bposd import BpOsdDecoder

cx, cz = codes.bivariate_bicycle_code(6, 6, ...)
decoder = BpOsdDecoder(cx.parity_check_matrix(), error_rate=0.05, osd_order=0)
correction = decoder.decode(syndrome)

License verification

import os
from qector_decoder_v3.license import verify_license_token

token = os.environ.get("QECTOR_LICENSE", "")
is_valid = verify_license_token(token)
# Or with explicit email check:
is_valid = verify_license_token(token, customer_email="user@example.com")

License Keys (v1.0.0)

from qector_decoder_v3 import set_license_key, set_license_key_file, get_license_info

set_license_key("QECT-PRO-your-key")        # raises ValueError if the key is rejected
set_license_key_file("/path/to/license.key")  # or load it from a file

info = get_license_info()
print(f"Tier: {info['tier']}  status: {info['key_status']}")

The core also resolves a key on its own, in this order: QECTOR_LICENSE_KEY, then QECTOR_LICENSE_FILE, then ~/.qector/license.key. Prefer a file in deployments: the key then never appears in a process listing or shell history. Check info["key_status"] == "valid", not just the tier: a QECTOR_LICENSE_FILE that is set but unreadable is reported as an invalid key rather than silently falling back to Community.

Sinter integration

import sinter
from qector_decoder_v3.sinter_compat import qector_sinter_decoders

samples = sinter.collect(
    num_workers=4, tasks=tasks,
    decoders=["qector_belief", "qector_blossom", "qector_unionfind"],
    custom_decoders=qector_sinter_decoders(),
)

Decoder families

Module	Best use	Status
`UnionFindDecoder`	Low-latency approximate decoding	Stable
`FastUnionFindDecoder`	Optimized Union-Find hot path	Stable
`BlossomDecoder`	Exact MWPM / PyMatching-parity validation	Stable
`SparseBlossomDecoder`	Faster near-optimal matching	Experimental
`BeliefMatching`	Correlated-noise accuracy experiments	Research
`BpOsdDecoder`	LDPC / qLDPC decoding	Experimental
`BatchDecoder` / `CPUBatchDecoder`	CPU batch Monte Carlo sweeps	Stable
`CUDABatchDecoder`	CUDA batch decoding (optional `edge_weights`)	Build/runtime dependent
`CUDABpOsdDecoder`	CUDA BP-OSD batch decoding	Build/runtime dependent
`OpenCLBatchDecoder`	OpenCL batch decoding (optional `edge_weights`)	Build/runtime dependent
`SpaceTimeDecoder`	3D space-time (multi-round) decoding	Experimental
`AutoDecoder`	7-tier self-debugging backend fallback	Stable
`PredecodedDecoder`	Easy-syndrome prefiltering	Experimental
`DecoderPool`	Multi-process batch decoding	Stable
`get_decoder` / `clear_decoder_cache`	Cached decoder factory	Stable
`decode_mmap`	Out-of-core memmap decoding	Stable
`DecodeResult` / `decode_with_diagnostics`	Structured decode results	Stable
`Workbench`	High-level orchestration	Stable
`SlidingWindowDecoder`	Multi-round streaming	Experimental
`StreamingDecoder`	Continuous streaming sessions	Experimental
`HybridDecoder`	Union-Find + Blossom fallback routing	Experimental
`LookupTableDecoder`	Precomputed small-code lookup	Experimental
`NeuralPredecoder`	Learned predecoder front-end	Research
`GNNPredecoder`	Graph neural network predecoder	Research
`GNNTrainer`	Training harness for GNNPredecoder	Research
`LERBenchmark`	Logical error rate benchmarking	Experimental
`stim_compat`	Stim circuit / DEM conversion	Stable utility
`sinter_compat`	Sinter custom decoder integration	Stable utility
`rest_api`	Local decoding service	Local/partner review

Self-Auto-Debug Backend Architecture (v0.6.8)

AutoDecoder implements a 7-tier fault-tolerant self-debugging fallback engine that automatically selects, monitors, and recovers from hardware failures:

Tier	Backend	Description
1	CUDA Batch	GPU batch decoding via NVRTC-compiled kernels
2	OpenCL Batch	Cross-vendor GPU batch decoding
3	CPU Rayon	Multi-threaded parallel CPU batch decoding
4	CPU Batch	Single-threaded CPU batch decoding
5	CPU Single	Per-syndrome CPU decoding
6	Blossom	Exact MWPM fallback (guaranteed correctness)
7	Lookup Table / Python	Pure-Python last-resort fallback

Key features:

Automatic error trapping: Hardware exceptions (CUDA OOM, driver crashes, memory limits) are caught, logged, and bypassed transparently.
Health scoring: Each backend tracks its health status. Failed backends are automatically suspended.
Seamless recovery: reset_backend_health() re-enables all backends for dynamic recovery.
Diagnostic logging: All fallback events and error details are recorded for debugging.

Licensing & Activation (v1.0.0)

Ed25519 Cryptographic License Verification

QECTOR uses offline Ed25519 signature verification for license tokens. No network calls required.

Token format: Self-contained 3-part tokens ({receipt_id}.{email_b64}.{signature_b64}) embed the customer email and cryptographic signature for fully offline verification.

Variable	Description
`QECTOR_LICENSE`	Set to a valid Ed25519-signed license token to activate
`QECTOR_SILENT`	Set to `1` to suppress the startup licensing notice

Override tokens: academic and commercial accepted for development and testing.

Tuning environment variables

These change decoder behaviour at construction time. Two of them affect matching quality, and therefore logical error rate; set them deliberately, and record them alongside any benchmark you publish.

Variable	Default	Effect
`QECTOR_BLOSSOM_K_MULT`	`2.0`	Candidate-neighbour multiplier for sparse MWPM: `k = max(12, ceil(mult · sqrt(n_defects)))`. Affects accuracy. Lowering it reduces latency but can exclude the optimal partner on dense instances, producing a heavier (sub-optimal) matching. `2.0` is the tuned minimum that preserved exact-MWPM parity at d ≥ 15.
`QECTOR_BLOSSOM_INTRA_PAR`	auto	Force intra-decode parallelism for candidate discovery. `0` disables, `1` forces. Unset selects automatically when the graph has ≥ 64 nodes (roughly d ≥ 9 for rotated surface codes). Performance only; output is bit-identical either way.
`QECTOR_BLOSSOM_INTRA_THREADS`	unset	Size a dedicated Rayon pool for candidate discovery, independent of the global batch pool. Unset or `< 1` uses the global pool. Performance only.
`QECTOR_CUDA_DEVICE_ID`	`0`	Which CUDA device the native batch/BP-OSD decoders bind to.
`QECTOR_OPENCL_DEVICE_ALLOW`	unset	Comma-separated substrings matched case-insensitively against OpenCL device names, e.g. `nvidia,geforce`. Unset accepts any device. Use it to avoid selecting an integrated GPU on multi-device hosts.

Only QECTOR_BLOSSOM_K_MULT and QECTOR_OPENCL_DEVICE_ALLOW can change results (matching quality and device selection respectively); the rest are purely throughput knobs.

Stripe Integration

Commercial licenses are issued automatically via Stripe Checkout:

Customer completes payment at qector.store
Stripe fires a checkout.session.completed webhook
The server generates an Ed25519-signed license token
Token is delivered to the customer

Direct purchase: Buy Commercial License

v1.0.0 highlights

Area	Description
`qector` CLI	`qector decode` / `bench` / `serve`, plus `qector-doctor`, a 15-check environment diagnostic that tells you why a decoder is unavailable instead of failing at decode time
Ecosystem entry points	Five Sinter decoders and the qiskit-qec plugin are now registered entry points, so `sinter.collect(decoders=["qector_blossom", ...])` works without `custom_decoders=`
`pymatching` shim	`from qector_decoder_v3.pymatching import Matching`, the submodule spelling, not only the attribute
New decoder families	`AmbiguityClusterDecoder` (BP + \|LLR\| partition + exact per-cluster enumeration), `TwoStageDecoder` (X sector, propagate, Z sector), `ColourCodeDecoder` (BP-OSD on the undecomposed hypergraph; matching is not a correct colour-code decoder)
Relay-BP	Layered serial BP schedule for qLDPC (`bp_method="relay"`); each check sees the freshest messages
Weighted Union-Find on the GPU	`CUDABatchDecoder` and `OpenCLBatchDecoder` accept `edge_weights` and run adaptive weighted growth; both kernels agree, which is the cross-check that the port is faithful
`DemModel.make_decoder`	Covers all nine shipped families, not five; a DEM is the entry point real circuit-level workloads use
Belief matching	`from_numpy_h` decoders no longer return empty corrections; output is a faithful length-`n_qubits` vector (`H @ corr == syndrome`)
BP-OSD accuracy	Exact log-domain sum-product BP by default; true combination-sweep OSD-1/2 via `osd_order`
Rust core: crash safety	Six panic-to-abort paths removed: gRPC and CUDA mutex-poison propagation, swallowed CUDA async errors, `Bernoulli::new` unwrap, cascade-decoder `expect`. Under `panic = "abort"` each of these killed the host process
Licence hardening	Malformed tokens return `False` instead of raising; v2 tokens carry tier + expiry inside the signature; `QECTOR_LICENSE_FILE` and `~/.qector/license.key` are read, and an unreadable file reports invalid rather than silently dropping to Community
Benchmark honesty	The pre-v0.7.0 comparison tables are withdrawn; `ler.assert_comparable` now blocks cross-noise-model comparisons at the source

v0.6.8 highlights

Area	Description
Self-Auto-Debug Backend	7-tier fault-tolerant fallback engine with automatic error trapping and health scoring
Ed25519 License Verification	Offline cryptographic license token validation
Stripe License Fulfillment	Automated commercial license issuance via Stripe Checkout
SparseBlossom bugfix	All decoded syndromes now bit-identical to MWPM
BPOSD timeout bugfix	Wall-clock deadline now honored from the first iteration
OpenCL health check fix	Child-process `NameError` in `_opencl_health_check()` fixed
`k_nearest_via_radix`	Public event-driven candidate-edge discovery
MCP server expansion	5 new tools, expanded decoder info
Cross-decoder test suite	Covers all 11 decoder families
SafeTensors round-trip tests	Full dtype, shape, and error-path coverage
Dead-code elimination	8 warnings eliminated across the crate

Benchmark evidence

Withdrawn: the pre-v1.0.0 comparison tables

Four benchmark tables that stood here: MWPM parity vs PyMatching at d=13/15, belief-matching LER at d=5/7, GPU bit-identity, and the native memory profile, are withdrawn. Do not cite them.

Two independent reasons, either sufficient:

Incompatible methodologies in one table. The comparison ran QECTOR under code-capacity noise and PyMatching under circuit-level noise, then printed both LER columns side by side. Those two numbers are not comparable, so the "parity" the tables reported was an artifact of the harness, not a property of the decoders.
The artifacts are unobtainable. Each table cited a file under benchmark_results/, a path that is in .gitignore and has never been part of any published commit or wheel. The files are also no longer on disk. Nobody could have checked the numbers even when they were displayed.

The numbers are not being quietly deleted; they are being retracted, because the method that produced them cannot support the claim they were used to make. qector_decoder_v3.ler now tags every run with its noise model and refuses cross-model comparisons through assert_comparable, so this class of error cannot recur silently.

What replaces them: scripts/regenerate_benchmark_artifacts.py and scripts/run_custom_comparison_benchmark.py both drive every decoder through one circuit-level pipeline: ler.estimate_ler_circuit_level, one Stim circuit, one decomposed DEM, one detector/observable sample set per cell, one decode_batch resolver, scored against the circuit's own logical observables; and stamp the result with its methodology, git commit, tree-dirty flag, parameters and dependency versions. ler.assert_comparable gates the rows before they are written.

python scripts/regenerate_benchmark_artifacts.py --dry-run   # show the plan
python scripts/regenerate_benchmark_artifacts.py --yes       # ~1.6M decodes

# QECTOR vs PyMatching vs ldpc, with a per-cell time budget:
python scripts/run_custom_comparison_benchmark.py \
    --distances 3,5,7,9,11,13,15 --shots 1000,5000,10000,50000,100000 --p 0.005

Verified v1.0.0 benchmark set

official_benchmark_results.{json,csv,md,pdf} in the repo root hold the verified v1.0.0 benchmark set: 54 measured cells, zero unfaithful corrections, taken through the package MCP server (stdio, JSON-RPC 2.0) on 2026-08-02T05:59:13Z (Linux glibc 2.35, Python 3.12.13).

Peak throughput: 11,540,387 shots/s (FastUnionFind, 5-qubit repetition code, 8,000 samples)
54/54 benchmark points with zero unfaithful corrections (repetition n=5-65, ring n=16-48; unionfind, fastunionfind, blossom, sparseblossom, bposd, auto)
42/42 syndrome-faithfulness cases passed; 13 MCP tools operational
No speedup multiplier is claimed. Apple-to-apple vs PyMatching (see benchmarks/v1.0.0/VERIFIED_APPLE_TO_APPLE_REPORT.pdf): comparable, with PyMatching often slightly ahead on the synchronized batch.

The previous official_benchmark_results.* (2026-08-01 circuit-level comparison, generated from a dirty working tree at b436f04e, carrying per-row speedup-vs-PyMatching multipliers) is withdrawn: it is not part of the verified release and must not be cited.

Benchmark figures are not published beyond the verified set for this release. Decoder throughput and logical error rate depend on your hardware, code family, distance and noise model, so any table printed here would describe a machine that is not yours. The benchmark harness ships with the package and writes JSON carrying its own environment and parameter block; run it on your target hardware (qector benchmark --verify or python -m qector.validate) and compare decoders under the conditions you actually care about.

GPU accuracy depends on whether matching weights are supplied. CUDABatchDecoder and OpenCLBatchDecoder accept an optional edge_weights argument. Omitting it selects topology-only cluster growth, whose logical error rate does not improve with code distance: the signature of operation above threshold. Supplying the DEM's log((1-p)/p) weights restores distance scaling. The weighted path costs more per shot than the unweighted one. docs/BENCHMARK_COMPETITIVE.md records the same effect for unweighted Union-Find on CPU. See the quick-start above for the weighted construction.

Backend agreement. CUDA and OpenCL returned identical logical-failure counts in every cell where both ran, consistent with the bit-identity property recorded elsewhere in this project.

GPU throughput and GPU logical error rate should be cited together. The unweighted configuration is the fastest column in the table and simultaneously the least accurate; either figure alone misrepresents it.

Neither finding generalises beyond the cells above. Regenerate on quiesced hardware, and state the noise model, before any number here is used in a claim.

Published, citable evidence

Until that run lands, the reproducible accuracy and throughput evidence for this project lives in the archived datasets, not in this file:

Record	What it establishes	Methodology
10.5281/zenodo.21501377: Empirical benchmarks, v0.6.8 (CC-BY-4.0)	Archived empirical benchmark dataset for v0.6.8, including syndrome-faithfulness verification (`H·ê = s`) and matching parity against PyMatching	Circuit-level, single pipeline. Ships 5 raw JSON datasets, 6 repro scripts, and a `manifest.json` carrying the wheel SHA256 and pinned dependency versions. Host: HP dual-core, 3.1 GB RAM, AntiX live USB, Python 3.13.5, pymatching 2.4.0, stim/sinter 1.16.0
10.5281/zenodo.21339300: Workbench benchmark master report, v0.6.6 (CC-BY-4.0)	1,858 measurements over 105 runs; latency, throughput and peak memory for `d = 3-19` across 6 topologies	`p = 0.05`. Reports QECTOR decoders against each other; it is not a cross-library comparison

Both are one release behind the working tree (v0.6.8 and v0.6.6 against 1.0.0); read them as evidence about those versions.

Benchmark results are hardware, driver, compiler, and workload dependent. Regenerate before quoting performance numbers, and state the noise model: code-capacity and circuit-level LERs are different quantities.

Reproduce benchmarks

# Every decoder family, one circuit-level pipeline, LER + Wilson CI + latency
# + syndrome faithfulness. Writes a JSON stamped with its own environment.
python scripts/full_decoder_benchmark.py

# The publication artifact: circuit-level throughout, provenance block embedded
python scripts/regenerate_benchmark_artifacts.py --yes

# MWPM / PyMatching comparison
python scripts/competitive_stim_ler.py --distances 3 5 7 9 11 13 15 --shots 40000

# Belief-matching comparison
python scripts/competitive_belief_matching.py --distances 3 5 7 --shots 3000 --no-ref

# GPU correctness
python scripts/gpu_extensive_test.py --distances 3 5 7 9 11 13 --batches 1 64 1024 4096 16384 65536 --error-rate 0.05

# Native memory profile
python scripts/native_memory_profile.py --distances 5 9 13 --batch 16384

These write into benchmark_results/, which is .gitignored; the output stays on the machine that produced it and is never committed. If you intend to publish a number, publish the artifact alongside it.

Architecture

qector_decoder_v3/
+-- Rust core (proprietary, injected during CI build or under license)
|   +-- Union-Find / Blossom / SparseBlossom engines
|   +-- CPU batch engine (SIMD-accelerated on x86)
|   +-- CUDA / OpenCL batch paths
|   +-- DEM collapse and Stim integration
|
+-- Python layer (open source in this repository)
    +-- __init__.py, backend.py, dem.py
    +-- belief_matching.py, bposd.py
    +-- predecoder.py, codes.py
    +-- stim_compat.py, sinter_compat.py
    +-- qiskit_plugin.py, rest_api.py
    +-- workbench.py

REST API (local use only)

pip install "qector-decoder-v3[stim]" fastapi uvicorn
python -m qector_decoder_v3.rest_api

curl -X POST http://localhost:8000/decode \
  -H "Content-Type: application/json" \
  -d '{"check_to_qubits":[[0,1],[1,2],[2,3],[3,4]],"syndrome":[0,1,0,0]}'

For local experiments and controlled deployments only. Not hardened for public SaaS.

MCP server (stdio)

The package ships an MCP server (JSON-RPC 2.0 over stdio) in every published wheel, no extra feature flag or install is needed:

python -c "import qector_decoder_v3; qector_decoder_v3.run_mcp_server()"

A ready-made client configuration lives in mcp.json at the repository root (it launches python -c "import qector_decoder_v3; qector_decoder_v3.run_mcp_server()" with QECTOR_SILENT=1). Point your MCP client at that file, e.g. Claude Code supports mcp.add with the qector server name. The server advertises 13 tools, all verified on the released wheel:

Tool	Purpose
`decode_syndrome`	Decode a syndrome with any decoder family (Union-Find, Blossom, SparseBlossom, BP-OSD, Cascade, Hybrid, and more)
`batch_decode`	Batch-decode multiple syndromes in parallel
`decode_hyperedge`	Hyperedge / qLDPC decoding (bypasses graphlike Union-Find restrictions)
`decode_syndrome_blossom` / `batch_decode_blossom`	Exact Blossom (MWPM) single and batch
`decode_syndrome_cascade`	Hybrid cascading decoder (UF pre-filter escalating to Blossom)
`benchmark_decoder`	Run a performance benchmark for a decoder family
`run_ler_benchmark`	LER benchmark across code distances
`get_decoder_info`	Decoder configuration, version info, family listing
`get_backend_health`	Backend health status across the 7 fallback tiers
`clear_decoder_cache`	Clear the decoder factory cache
`get_server_env`	Effective QECTOR environment variables
`recommend_decoder`	Decoder recommendation by code topology and priority

The stdio reader enforces a 10 MB content limit and validates syndrome lengths and decoder types, returning JSON-RPC errors instead of crashing. For local and controlled use; like REST/gRPC, it is not hardened for public SaaS exposure.

Limits and boundaries

Area	Boundary
MWPM latency	PyMatching remains faster than exact `BlossomDecoder` on standard surface-code MWPM. QECTOR's value is decoder breadth and qLDPC coverage, not beating PyMatching at its own workload
Belief-matching	Accuracy/research mode; can improve LER but much slower
GPU accuracy	Unweighted GPU kernels trade logical accuracy for throughput; pass `edge_weights` or accept that
GPU performance	Speedup is not universal, and the weighted kernel is currently slower than the weighted CPU path
Benchmark tables	The pre-v0.7.0 comparison tables are withdrawn (see above). Cite the archived datasets or regenerate
OpenCL	Depends on build configuration; confirm locally
SparseBlossom	Near-optimal, not exact MWPM; use `BlossomDecoder` for exact
UnionFind	Fast approximate path; not universal for arbitrary graphs
REST/gRPC/MCP	Not hardened as public SaaS without separate security review

Licensing

QECTOR Decoder v3 is source-available under the PolyForm Noncommercial License 1.0.0 (see LICENSE). Personal, academic, educational, and non-commercial research use is allowed. Company use, funded institutional work, SaaS, hosted API deployment, OEM integration, redistribution, paid consulting, or commercial benchmarking requires a commercial license.

Pricing & tiers: https://www.qector.store/pricing
Direct purchase: Buy via Stripe
Contact: admin@qector.store

DOI references

Licensing terms & user manual: 10.5281/zenodo.21363016
Performance benchmarks (v0.6.6): 10.5281/zenodo.21339300
Architecture whitepaper: 10.5281/zenodo.21320543
Empirical edge-hardware benchmarks (v0.6.8): 10.5281/zenodo.21501377
Workbench GUI v0.5.3: 10.5281/zenodo.21360433
Provenance archive (restricted): 10.5281/zenodo.20825980

@software{lessard2026qector,
  author  = {Guillaume Lessard},
  title   = {{QECTOR Decoder v3}: Rust/Python Quantum Error Correction Decoding Platform},
  year    = {2026},
  version = {1.0.0},
  url     = {https://www.qector.store},
  note    = {Source-available under PolyForm Noncommercial 1.0.0. Commercial license required for commercial use.}
}

https://www.qector.store · admin@qector.store

quantum error correction decoder union-find QEC rust MWPM Stim Sinter PyMatching qiskit LDPC qLDPC blossom belief propagation belief matching BP-OSD Relay-BP colour code color code toric code GPU decoding CUDA surface code syndrome decoding fault tolerance quantum computing

Download files

Download the file for your platform. If you're not sure which to choose, learn more about installing packages.

Source Distributions

No source distribution files available for this release.See tutorial on generating distribution archives.

Built Distributions

If you're not sure about the file name format, learn more about wheel file names.

The dropdown lists show the available interpreters, ABIs, and platforms. Enable javascript to be able to filter the list of wheel files.

qector_decoder_v3-1.0.0-cp313-cp313-win_amd64.whl (2.0 MB view details)

Uploaded Aug 6, 2026 CPython 3.13Windows x86-64

qector_decoder_v3-1.0.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (2.2 MB view details)

Uploaded Aug 6, 2026 CPython 3.13manylinux: glibc 2.17+ x86-64

qector_decoder_v3-1.0.0-cp313-cp313-macosx_11_0_arm64.whl (1.9 MB view details)

Uploaded Aug 6, 2026 CPython 3.13macOS 11.0+ ARM64

qector_decoder_v3-1.0.0-cp312-cp312-win_amd64.whl (2.0 MB view details)

Uploaded Aug 6, 2026 CPython 3.12Windows x86-64

qector_decoder_v3-1.0.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (2.2 MB view details)

Uploaded Aug 6, 2026 CPython 3.12manylinux: glibc 2.17+ x86-64

qector_decoder_v3-1.0.0-cp312-cp312-macosx_11_0_arm64.whl (1.9 MB view details)

Uploaded Aug 6, 2026 CPython 3.12macOS 11.0+ ARM64

qector_decoder_v3-1.0.0-cp311-cp311-win_amd64.whl (2.0 MB view details)

Uploaded Aug 6, 2026 CPython 3.11Windows x86-64

qector_decoder_v3-1.0.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (2.2 MB view details)

Uploaded Aug 6, 2026 CPython 3.11manylinux: glibc 2.17+ x86-64

qector_decoder_v3-1.0.0-cp311-cp311-macosx_11_0_arm64.whl (1.9 MB view details)

Uploaded Aug 6, 2026 CPython 3.11macOS 11.0+ ARM64

qector_decoder_v3-1.0.0-cp310-cp310-win_amd64.whl (2.0 MB view details)

Uploaded Aug 6, 2026 CPython 3.10Windows x86-64

qector_decoder_v3-1.0.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (2.2 MB view details)

Uploaded Aug 6, 2026 CPython 3.10manylinux: glibc 2.17+ x86-64

qector_decoder_v3-1.0.0-cp310-cp310-macosx_11_0_arm64.whl (1.9 MB view details)

Uploaded Aug 6, 2026 CPython 3.10macOS 11.0+ ARM64

qector_decoder_v3-1.0.0-cp39-cp39-win_amd64.whl (2.0 MB view details)

Uploaded Aug 6, 2026 CPython 3.9Windows x86-64

qector_decoder_v3-1.0.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (2.2 MB view details)

Uploaded Aug 6, 2026 CPython 3.9manylinux: glibc 2.17+ x86-64

qector_decoder_v3-1.0.0-cp39-cp39-macosx_11_0_arm64.whl (1.9 MB view details)

Uploaded Aug 6, 2026 CPython 3.9macOS 11.0+ ARM64

File details

Details for the file qector_decoder_v3-1.0.0-cp313-cp313-win_amd64.whl.

File metadata

Download URL: qector_decoder_v3-1.0.0-cp313-cp313-win_amd64.whl
Upload date: Aug 6, 2026
Size: 2.0 MB
Tags: CPython 3.13, Windows x86-64
Uploaded using Trusted Publishing? Yes
Uploaded via: twine/7.0.0 CPython/3.13.14

File hashes

Hashes for qector_decoder_v3-1.0.0-cp313-cp313-win_amd64.whl
Algorithm	Hash digest
SHA256	`a8f09b6849a006f8c1c540be4a44d5aab12f9ae579f74aabb98c1f4336bb6d88`
MD5	`9e155930cc6d0308e4c72379b2e945b2`
BLAKE2b-256	`703325eae1b8b8f2e66f64c3d0bd7994432b195e267515f3aaff5839ea44e155`

Algorithm	Hash digest
SHA256	`02812bc01a2dff105b144896b1216e164bc67939483b6036c3ebcbcf6324f94a`
MD5	`c19858fd8636666ed76fe1599e780cd6`
BLAKE2b-256	`bb8af613e86e770ac13bde29bf74ef3246e8510435ef66dd51fd41f06415881d`

Algorithm	Hash digest
SHA256	`db730d84c3006a3640e18b4fe4716161303198b1cebe2f596cf569e4e178dce4`
MD5	`5c077eccc0aa7dfeb35d6bccf685b0bf`
BLAKE2b-256	`a4ea2960b9cb6d97ec1ba78d907a3b87a6faad75ff241362d5a66fbff074f963`

Algorithm	Hash digest
SHA256	`62c6569b656c584344168a4478e91912866a015542d06d6fb8d327deb6e377cd`
MD5	`9f913893e79d13817de3d9ae803d7c3f`
BLAKE2b-256	`2abd97a6e45e91daeff97537d8c8fd7e28c5726890a48e0f70a5b78a77764808`

Algorithm	Hash digest
SHA256	`dca105a1cdbbaf802cf8426e9f3a414ee1a3965380549531df88e3f06484276f`
MD5	`7ba8899953ec2cd40aee5d10e9d31c2a`
BLAKE2b-256	`7689cd0c630437ae2fd93d57b205894b98be02186b8404fdbf16f45ec6a756ef`

Algorithm	Hash digest
SHA256	`64a9355daecb307affa098a8e17ad69b8c4486933bc09f3da8c46947b320979e`
MD5	`d0429954c6b170f1abeedf635498e772`
BLAKE2b-256	`4eacb055a8155e5009fee6ecfddecd3aee24b3e35b814ce4a9f1473177428d01`

Algorithm	Hash digest
SHA256	`7f198c7d9ca8f28c461f907d2ec4f41464198446abc2239c894b550bce7d4f98`
MD5	`4acc8c7e22e3938089a36e5037648a08`
BLAKE2b-256	`1fcd3564546f8fc68a2716d7799e780ef8618f062022db9db3261250c60ceab0`

Algorithm	Hash digest
SHA256	`9ee1da96e08e6e841e6d8768a830e253c229380e41454f26971d8bd4cc385575`
MD5	`5ee8a37b9ae0072c37a9ec5eb3cd7c33`
BLAKE2b-256	`a57b3575e02e32661ddffb2c3d85c61ecaf725f4a9d6e33ba940504edd5e3910`

Algorithm	Hash digest
SHA256	`b3a6260b4daa12552ae7cc4a899e337361ec3b7a2dec71b291ab253252b322c2`
MD5	`1250d2971656763a8fe6cc919fb44962`
BLAKE2b-256	`989880daa90c4b11759e080df16e6c15aea770b61e13b9e30ca5a4822f6437cf`

Algorithm	Hash digest
SHA256	`3d045a87954aea8f7ef83407bb90ddc32d6b42b44ed2d712420b6b18bdbec870`
MD5	`7dd5ecd529a86a480376df8035f4061a`
BLAKE2b-256	`847d0651df3436789efe2e3aa8264c7eeb0539e67362a17b5e6ffd7762cc7b17`

Algorithm	Hash digest
SHA256	`6a7f1a23ea20c1adb56754750e02590e94e32cac506567781a278850b216e30c`
MD5	`f1dbc9c39f7e1f40080f2f5b0f053500`
BLAKE2b-256	`94116eeea4803a5f4cfae3f72405360411e07b07c4f1dd9559d06370fe97097c`

Algorithm	Hash digest
SHA256	`08efc3944299c912d26ab76f7fe79684e859877981ff555c52b6ce89b6fa5f01`
MD5	`f2e68f333778af98008fce6d64990ebd`
BLAKE2b-256	`b1e615d469982ef7d9ebafc9c55f36830bc2a748edf446fd6d21b8d61a906a70`

Algorithm	Hash digest
SHA256	`20efe31fa8629098f24f5a6306412b2c1f19ed00cb53c194440aa0162d33403e`
MD5	`3c46ec5c0008832881cde1a49a2c523d`
BLAKE2b-256	`1852cd50386fe06e397f53abb24c9433da4094990cfe3e5e866eb6dfe977486e`

Algorithm	Hash digest
SHA256	`3c9e847855a5aabcc721fcc056394264d0b63dfa71ac72902e1bd9ac35e47653`
MD5	`4faa4e8cb68297d2c062bc746f091198`
BLAKE2b-256	`4c2c79ee5e8aee1d9da93f23ee29fd89626c5b0c4fa9736c640e48b914212e8e`

Algorithm	Hash digest
SHA256	`44284e2d57208637d499017ddfa940e3c61c9302b1ba06c322490aaa92e4f20a`
MD5	`536bc76ed73214a65143b86452c01041`
BLAKE2b-256	`09b113a7cf3907ad1efffa719b05ae915793ec27bb6e54e488dbe0fd05dde7b7`

qector-decoder-v3 1.0.0

QECTOR Decoder v3

🚀 Support QECTOR Development

Install

Quick start

Batch decoding

AutoDecoder: 7-tier self-debugging fallback

Stim workflow

BP-OSD for LDPC / qLDPC codes

License verification

License Keys (v1.0.0)

Sinter integration

Decoder families

Self-Auto-Debug Backend Architecture (v0.6.8)

Licensing & Activation (v1.0.0)

Ed25519 Cryptographic License Verification

Tuning environment variables

Stripe Integration

v1.0.0 highlights

v0.6.8 highlights

Benchmark evidence

Withdrawn: the pre-v1.0.0 comparison tables

Verified v1.0.0 benchmark set

Published, citable evidence

Reproduce benchmarks

Architecture

REST API (local use only)

MCP server (stdio)

Limits and boundaries

Licensing

DOI references

Project links

Key dates

1 maintainer

Credits

GitHub Statistics

License

Requires

Provides Extra

Tags

Classifiers

Download files

Source Distributions

Built Distributions

File details

File metadata

File hashes

Provenance

File details

File metadata

File hashes

Provenance

File details

File metadata

File hashes

Provenance

File details

File metadata

File hashes

Provenance

File details

File metadata

File hashes

Provenance

File details

File metadata

File hashes

Provenance

File details

File metadata

File hashes

Provenance

File details

File metadata

File hashes

Provenance

File details

File metadata

File hashes

Provenance