// PQCF · started 30 October 2026

PQCF: a scientific engine
with distributed execution.

One open-source framework with two parts that applications use together. It began as a photonic simulator; its scientific engine now reaches into mathematical physics. Its execution layer runs other applications' work across one owner's machines; execution on federation peers is in development.

// Release status

What is in PQCF 1.4.0,
and what is newer.

Released: PQCF 1.4.0 (8 November 2026)
  • Photonic simulation: Gaussian and Fock states, density matrices with loss, boson and Gaussian boson sampling, gradients, noise models, the GPU kernels
  • The symbolic engine and compiled programs
  • Reconstruction over finite fields and Feynman-integral reduction
  • Execution on one machine and across one owner's Erlang nodes
  • The interface, frozen since 1 November: changes are additive until 2.0
Newer, on the main branch, not yet in a tagged release
  • The task layer for any application's work, with provenance records
  • Mathematical physics: gcd and factorisation, series, spectra, geometry, holographic QCD
  • Quantum optics
  • QFT and QCD: Feynman diagrams and rules, Dirac traces, one-loop integrals, the running of QCD
  • The executor for federation peers: a prototype in GenHub2; native in PQCF, in development

Release 1.4.0 does not contain the newer work. Each result's step-by-step page names the commit it was tested at: reproduce it there, not from the release.

// Architecture

Three layers:
applications, PQCF, the federation.

PQCF in three layers, and the path of a task The applications: GenHub2, photonic simulation and scientific computing. PQCF: its scientific engine and its distributed execution, with executors for one node and for one owner's nodes (both done), and for federation peers (a prototype in GenHub2; the native PQCF executor is in development). Below, the execution infrastructure that FVLLMP provides: each lab's own NVIDIA DGX Spark nodes, mutual-TLS gates, no central point. A task, plain data, goes from an application to an executor, runs on a node, and its result returns with its provenance record, checked by hash. Applications what people use GenHub2 virus classification for genetic labs every analysis a PQCF task Photonic simulation Gaussian and Fock backends, boson and Gaussian boson sampling Scientific computing QFT, QCD, Feynman integrals, quantum optics, holographic QCD PQCF Erlang/OTP and Rust Distributed execution plain-data tasks: the same result on any node pq_task an application's work as data executor: this node done executor: one owner's nodes done executor: federation peers prototype in GenHub2 native in PQCF in development provenance task hash, code checksum, node, time Scientific engine exact and numerical, each part checked against established tools photonic Gaussian, Fock, permanents, hafnians, sampling symbolic exact expressions, compiled programs, gcd, factor reconstruction finite fields; Feynman-integral reduction analysis series, ODEs, spectra, any precision physics QFT, QCD, geometry, quantum optics kernels Rust NIFs on CPU, permanents on GPU tasks Execution infrastructure: FVLLMP's federation Each lab's own NVIDIA DGX Spark nodes; mutual-TLS gates between them; no central point NVIDIA DGX Spark · DGX-1 PQCF with GenHub2 the lab's node: raw data stays here NVIDIA DGX Spark · DGX-2 the federation node runs a peer's tasks in containers NVIDIA DGX Spark · DGX-n a PQCF node more labs as they join mTLS mTLS GA4GH TES prototype designed to run on the federation's nodes solid: implemented · dashed: prototype or planned
PQCF's scientific engine and task architecture are designed to work with FVLLMP's distributed infrastructure. The diagram distinguishes implemented execution, the GenHub2 federation prototype and the federation-peer executor still in development in PQCF: done prototype in development. Solid lines: implemented; dashed: a prototype or planned.

Scientific engine

  • Photonic simulation
  • Symbolic computation
  • Finite-field reconstruction
  • Feynman-integral reduction
  • Mathematical physics

Execution and provenance

  • Plain-data tasks
  • Executors: one machine, one owner's nodes done; federation peers prototype
  • Task hashes and code checksums
  • Node and execution metadata with every result
  • Erlang/OTP orchestration, Rust kernels

Applications

The path of a task.

  1. An application submits a task: plain data.
  2. An executor chooses where it runs: this node or another of the owner's nodes (implemented); a federation peer (prototype).
  3. The node runs it, every input named by its SHA-256.
  4. The result returns with its provenance record, checked by hash: the same task gives the same bytes on any node.

PQCF and FVLLMP. FVLLMP is the distributed software infrastructure being developed for execution across independent nodes; PQCF is the scientific-computing framework that is designed to use it. FVLLMP originated in the infrastructure work for TechUPGRADE and is being prepared for validation across an initial ten nodes. Discover FVLLMP →

What stays at the lab, and what leaves it. In GenHub2, the steps that read a laboratory's raw data (the upload's validation, the removal of human reads, the screening of the reads and the consensus genome built from them) run only on the lab's own node; they are never sent to another node. What a task may carry to another of the owner's nodes or, through the federation, to a peer is its inputs, named by their SHA-256: so far, genome sequences derived from the samples or from public records (the federation test sent an alignment of 1,000 public SARS-CoV-2 genomes). Results, aggregated counts and datasets a lab approves are what travel between labs; patient-linked data is not pooled. A peer runs a task in a container with no network and a read-only file system, and returns only its outputs.

What is a prototype. Executors for one machine and for one owner's machines are part of PQCF and tested. The executor for federation peers exists as a prototype in GenHub2's repository: its first tasks ran on a second DGX Spark through the federation's GA4GH TES route on 17 November, with identical results, and slower than on the lab's own cores. Moving it into PQCF itself, as a native executor, is in development.

// Status

What is released,
and what is not yet.

Tested
checked by our own tests against an independent reference
Benchmarked
timed against an established tool on the same machine
Reproduced
rerun by us from a fresh clone, with a step-by-step page
Prototype
working, but not yet in its final place or form
In development
implementation underway; not yet complete
Planned
intended work that has not started
Independently reviewed
evaluated by a reviewer outside the development team: nothing yet
capabilitystatussince
Gaussian and Fock simulation, boson sampling, gradients, noise modelsReleased Benchmarked Reproduced1.0–1.2, 1–5 November
Permanents and hafnians on an NVIDIA GPUReleased Tested1.1, 5 November
The symbolic engine, compiled programsReleased Benchmarked Reproduced1.3, 7 November
Reconstruction over finite fields, Feynman-integral reductionReleased Benchmarked Reproduced1.4, 8 November
Executors for one machine and for one owner's machinesReleased Tested1.0 (sampling), 1.4 (reconstruction)
The task layer: plain-data tasks for any application, provenance recordsTested, on main, not in a release13 November
Mathematical physics: gcd and factorisation, series, spectra, geometry, holographic QCDTested Reproduced, on main14–15 November
Quantum opticsTested Benchmarked Reproduced, on main14–16 November
QFT and QCD: diagrams, rules, Dirac traces, one-loop integrals, running of QCDTested Reproduced, on main16–18 November
The executor for federation peersPrototype in GenHub2; In development in PQCF17 November
Independent review of the physics; a release with a DOINot yet
// Started 30 October 2026 · becoming a platform

How PQCF began,
and what it guarantees.

We have started building PQCF, the Photonic Quantum Computing Framework: a simulator for quantum computing with light, open source from its first commit. QxFock and QxCV above are small demonstrations — a few photons, one optical mode. PQCF is meant for real work: circuits of many modes, the sampling experiments photonic hardware runs, and runs spread over many machines.

PQCF is becoming a platform: a distributed task layer, with photonic simulation as its first workload and GenHub2 as its first application.

  • Plain-data tasks: a task's result is the same whichever node runs it.
  • Executors: they spread the tasks over the machines.
  • Provenance: a record of every result.

What exists today:

  • the task behaviour and the provenance records, on main since 13 November;
  • executors for one machine and for one owner's machines.

What is next: the executor for peers in a federation of independent lab nodes. Its prototype, in GenHub2, sends tasks through the federation's GA4GH TES route, and its first tasks ran on a second DGX Spark with identical results (17 November); next it moves into PQCF.

How it is built. The orchestration is an Erlang/OTP application: jobs, workers, distribution across nodes and recovery when a node fails, where the BEAM is strong. The numerical kernels — permanents, hafnians, Gaussian and Fock-space operations — are in Rust, loaded into the BEAM as native functions. Our own benchmarks show why: the BEAM loses at raw single-thread arithmetic, and these kernels grow exponentially with the number of photons.

Goals
  • Simulate photonic circuits three ways: Gaussian states, Fock states, and density matrices with photon loss.
  • Boson sampling and Gaussian boson sampling: exact probabilities and exact samplers, with photon-number-resolving and threshold detectors.
  • Circuits with symbolic parameters: the exact symbolic unitary of an interferometer, and gradients for optimisation.
Guarantees
  • Reproducible: the same seed gives the same samples bit for bit, on 1 thread or 64, on one machine or many.
  • Fault tolerant: a job continues when a machine running part of it fails.
  • Checked: every kernel against independent tools — thewalrus, Strawberry Fields, Piquasso, Perceval — and against published values, with the tests in the repository.
Plan
  • Phase 0: foundations — core types, the random-number stream, the permanent, the symbolic engine.
  • Phase 1: Gaussian and Fock simulation and boson sampling on one machine.
  • Phase 2: Gaussian boson sampling, loss and noise, many machines.
  • Phase 3: speed, exchange with other tools, a stable interface.
  • Phase 4: the specification's roadmap — feed-forward, gradients, noise models, GPU offload, compact density matrices.
Today
  • Phases 0–3 are done: every requirement of the specification is implemented and tested. The test suite runs on x86_64 and ARM on every change.
  • Version 1.4.0, released on 8 November: reducing large symbolic results, among them Feynman integrals, 3 to 7 times faster than FIRE on its own double box (below; release notes). Before it, 1.3.0 measured the symbolic engine against FORM (below, 7 November), 1.1.0 completed Phase 4 and 1.2.0 added a Python client and faster density matrices (both 5 November). The interface has been frozen since 1 November (1.0.0-rc.1), so every change since is backward compatible.
  • The task layer: any application's work runs as PQCF tasks with provenance records (13 November); GenHub2 is the first application to use it.
  • The source is public under Apache 2.0: github.com/quanterall/pqcf.
// PQCF 1.1 · released 5 November 2026

What the roadmap added,
measured.

Release 1.1.0 completes Phase 4, the roadmap of PQCF's specification. Every change is backward compatible: code written for 1.0 runs unchanged and gives the same results, bit for bit (release notes).

  • Detection: threshold detectors on displaced light.
  • Feed-forward: gates that depend on earlier measurements in the same run.
  • Gradients: one forward and one backward pass for any number of parameters, also through photon loss, and exact parameter-shift rules.
  • Noise: partially distinguishable photons, extra photons from imperfect sources, detector dark counts, and loss to a thermal environment.

On a GPU. Permanents and hafnians can run on an NVIDIA GPU. Each GPU thread computes exactly the terms the CPU computes, bit for bit, so the two devices agree to the last rounding and every result is reproducible. On our GB10, the permanent passes 20 CPU threads from 24 × 24, and at 28 × 28 it takes 0.31 seconds against 0.91. The hafnian is not faster there: its double-precision arithmetic is the GB10's weak spot, so by default it stays on the CPU.

Two panels on log time axes. The permanent: GPU times from 23 milliseconds at n = 16 to 0.31 seconds at n = 28, CPU times on 20 threads from 1.4 milliseconds to 0.91 seconds; the lines cross at n = 24, where PQCF switches to the GPU. The hafnian, m = 24 to 36: the GPU is 3.3 to 5 times slower than 20 CPU threads

Smaller density matrices. Circuits with loss need density matrices, which grow with the square of the number of states. PQCF 1.1 can store them in blocks by photon number and skip the blocks that are zero. For a circuit that conserves photon number only the diagonal blocks remain: a 4-mode state with up to 20 photons then needs 0.18 GB instead of 1.81 GB, with the same results.

Memory of a 4-mode density matrix against the photon cutoff, log scale: the full matrix grows from 0.08 MB at cutoff 4 to 1.81 GB at cutoff 20, the photon-number blocks of a number-conserving circuit from 0.03 MB to 184 MB, about a tenth; the full matrix is refused from cutoff 16

The performance requirements, re-measured on 1.1.0. These are still provisional: the machine is shared, until our dedicated one arrives.

  • The permanent: 0.90 to 1.14 times the fastest method of thewalrus (required: at most 1.5).
  • Boson sampling on one machine: parallel efficiency 0.80 on all ten fast cores (required: at least 0.8).
  • Across four nodes: 0.87 (required: at least 0.7).