A quantum random number generator (QRNG) produces random bits by measuring a quantum process, for example by checking which path a single photon takes. Under quantum mechanics, nobody can predict such an outcome better than a blind guess, so a QRNG has no seed or formula for an attacker to recover (Ma et al., npj Quantum Information 2016).
Pseudorandom, classical and quantum generators
A pseudorandom generator in software runs a formula. Anyone who learns the formula and its inputs can reproduce its entire output (Quip docs: QVRF). Classical hardware generators read physical noise instead. Jacak et al. argue these devices are pseudorandom as well, because classical physics is deterministic (Jacak et al., Scientific Reports 2021). Their paper lists attacks tied to weak random numbers, including a 2010 attack on users of Sony's PlayStation 3 and the 2015 theft of 18,866 bitcoins from the Bitstamp exchange.
Quantum entropy sources
Ma et al. sort practical designs by detector type:
- Single-photon detectors. The device records a photon's path or its arrival time. Silicon detectors of this kind need tens of nanoseconds to recover after each detection, which Ma et al. say limits path-based designs to tens of megabits per second. Arrival-time designs in their survey reach 180 Mbps raw.
- Macroscopic photodetectors. The device measures vacuum noise or the phase noise of light. A phase-noise design reached a raw rate of 80 Gbps.
Classical noise always mixes into the quantum signal. Designers model it and remove it in post-processing, which lowers the final output rate (Ma et al.).
Trust levels for QRNG hardware
Ma et al. group QRNGs by the level of trust in the hardware:
- Practical QRNGs assume a fully trusted, calibrated device. They run fastest.
- Self-testing QRNGs, also called device-independent, prove their randomness by detecting entanglement through a Bell test. With a self-testing device, the user needs no trust in the hardware but gets slow output.
- Semi-self-testing QRNGs trust part of the setup. Jacak et al. describe this class as gaining speed at some cost in confidence.
Statistical test suites, such as NIST's suite and Dieharder, check output for patterns. The Jacak team's prototype passed both. Ma et al. caution that output tests can never stop a malicious generator from emitting a string chosen in advance. Quantinuum's glossary entry makes the same point and cites NIST. The same page describes running a Bell test on a quantum computer to prove randomness quality, and says Quantinuum's Quantum Origin product uses this method.
Time to produce a 256-bit key
We took the published rates for five designs and divided 256 bits by each rate. Rates come from Tables 1 and 2 of Ma et al. and from the abstract of Jacak et al.
| Design (year) | Trust class | Reported rate | Time for 256 bits |
|---|---|---|---|
| Optical Bell test (2013) | Self-testing | 0.4 bits/s | 640 seconds, almost 11 minutes |
| JUR02 prototype (2021) | Practical | 1 Mb/s | 256 microseconds |
| Vacuum noise, homodyne (2010) | Practical | 6.5 Mbps refined (10 Mbps raw) | about 39 microseconds |
| Source-independent, homodyne (2015) | Semi-self-testing | 1 Gbps | 256 nanoseconds |
| ASE phase noise (2015) | Practical | 68 Gbps refined (80 Gbps raw) | about 3.8 nanoseconds |
The fastest design in the table outputs bits about 170 billion times faster than the self-testing one. These are lab figures. For the phase-noise designs, Ma et al. stress that none of the speeds are real-time, because randomness extraction could not keep up. A developer choosing a QRNG trades speed against the amount of trust placed in the device.
Quantum randomness for smart contracts
A smart contract gets random values from a randomness oracle: the contract sends a request and receives the values later through a callback (Quip docs: QVRF).
Quip's QVRF service delivers randomness this way. According to quip.network/qvrf, the pipeline runs in four steps:
- Quantum hardware on the network runs circuits and returns raw samples.
- The service hashes every sample into a Merkle tree and publishes the root.
- After publishing, it picks a random subset, re-simulates it on classical hardware and scores it with cross-entropy benchmarking.
- A Toeplitz extractor condenses the audited samples into near-uniform bits.
The same page says the construction comes from a certified randomness protocol published in Nature in 2025, which a JPMorganChase-led team demonstrated on a 56-qubit trapped-ion processor.
The first version of QVRF has clear limits:
- Quip operates both the oracle and the trustee, so users trust a single operator (quip.network/qvrf).
- Verifying a transcript from a contract is still in development (quip.network/qvrf). The checks run after delivery, not at the moment of delivery (Quip docs: QVRF).
- Quip publishes its commitment on chain before delivery, so the operator could withhold values but could not swap them without detection (Quip docs: QVRF).
- The docs say the certification parameters, request interface and fee model are still being finalized.
- Despite its name, QVRF does not meet the cryptographic definition of a verifiable random function. The docs describe it as a physical randomness source with a verification record.
For more on the contract side, read Quantum randomness for smart contracts: how QVRF works.
Next step
To check the trust model before integrating, read the QVRF docs, then request access at quip.network/qvrf.
