Every quantum computer faces the same brutal arithmetic. Physical qubits are fragile, so you bundle many of them together to make one reliable logical qubit. The surface code, the workhorse of the field, is generous with that bundling. To reach the error rates needed for a serious calculation, it can spend a thousand or more physical qubits to protect just one logical qubit. Multiply that by the hundreds of logical qubits a useful program demands, and you arrive at machines with millions of parts. The overhead is the reason fault tolerance has felt so distant.
A different family of codes is trying to change that math. They go by the unlovely name quantum low-density parity check codes, or qLDPC, and the most talked-about member is something IBM researchers nicknamed the bicycle code.
What the surface code spends
The surface code earns its popularity honestly. It only asks each qubit to talk to its immediate neighbors on a flat grid, which is exactly what a two-dimensional superconducting chip can provide. That geometric simplicity is why so many companies chose it. The price is that the code stores information sparsely. A large patch of the checkerboard holds a single logical qubit, and most of those physical qubits are doing the humble work of watching for errors rather than storing anything useful.
The insight behind qLDPC codes is that you do not have to lay everything out on a tidy grid. If you allow a qubit to connect to a handful of partners that are not its nearest neighbors, you can weave a far denser web of parity checks. Denser checks mean a logical qubit can be defended without surrounding it in a vast moat of helpers.
The gross code
The specific version that drew attention is a construction IBM researchers described as a bivariate bicycle code, one instance of which they called the gross code. On paper it reads as [[144, 12, 12]]. That notation carries a lot of meaning. It uses 144 data qubits, encodes 12 logical qubits inside them, and can catch and correct enough errors to reach a distance of 12. Counting the check qubits, the whole thing runs on roughly 288 physical qubits.
Compare that to the surface code. To store 12 logical qubits with comparable protection, the checkerboard approach might swallow well over a thousand physical qubits. The bicycle code does it in a few hundred. The reported gain is close to an order of magnitude, and in a field where qubits are counted one painful fabrication run at a time, an order of magnitude is enormous.
The catch is the wiring
Nothing comes free. The reason the bicycle code is so compact is precisely the reason it is hard to build. Each qubit needs to connect to six others, and two of those connections reach across the chip rather than to a neighbor. On a superconducting processor, where couplings are physical wires and resonators etched into silicon, long-range links are a serious engineering headache. They crowd the layout, invite crosstalk, and defeat the neat planar geometry that made the surface code convenient.
This is why the arrival of these codes has pulled hardware and theory together. IBM's published roadmap leans on long-range couplers, sometimes described as c-couplers, meant to carry a qubit's signal across a chip so that the non-local checks of a bicycle-style code become possible. The code and the connector are being designed as a matched pair. You cannot adopt one without committing to the other.
Why the roadmaps care
The stakes are simple. If fault tolerance requires millions of physical qubits, it is a project for the 2040s. If a clever code cuts that requirement by a factor of ten, the timeline compresses dramatically. That is why qLDPC codes have moved from a corner of the literature into the center of serious planning. They offer a route to logical qubits that fits inside machines companies can imagine fabricating this decade rather than next.
There are still open problems. Performing logical operations between qubits encoded in these dense codes is trickier than the well-understood lattice surgery of the surface code, and decoding the error signals in real time demands fast classical processing. The bicycle code is not a finished answer. But it has reframed the question. The field spent years assuming the overhead of fault tolerance was a fixed cost of doing business. The bicycle code is the argument that it was never fixed at all, just unexamined.
