LDPC, Turbo & Polar Codes

In 1948 Claude Shannon proved something both thrilling and maddening: every noisy channel has a capacity, a maximum rate at which you can send data with vanishing error. Push below that rate with a clever enough code and your message arrives perfectly; push above it and no code on Earth can save you.

The maddening part? Shannon's proof was non-constructive. It promised that near-perfect codes exist without telling anyone how to build a practical one. For nearly fifty years the best engineers fell well short of the limit — there was always a stubborn gap of several decibels between theory and practice.

Then, in the 1990s and 2000s, three families of codes — turbo, LDPC, and polar — closed that gap to a fraction of a decibel. They are the reason your phone, your Wi-Fi, your satellite TV, and the rovers on Mars can speak clearly through a storm of noise.

Here is a tiny error-correcting code at work. Type a short message; the encoder adds parity bits that tie groups of message bits together with constraints. Then hit Add noise to flip random bits the way a real channel would — and watch the decoder use those parity constraints to figure out which bit is the liar and flip it back.

<p class="hint">{{hint}}</p>
<label class="msg">{{label_message}}
  <input id="text" type="text" maxlength="6" value="HI" />
</label>
<div class="legend">
  <span><i class="sw data"></i> {{legend_data}}</span>
  <span><i class="sw par"></i> {{legend_parity}}</span>
  <span><i class="sw flip"></i> {{legend_corrupted}}</span>
  <span><i class="sw fix"></i> {{legend_repaired}}</span>
</div>
<div id="grid" class="grid"></div>
<div class="status" id="status">{{status_clean}}</div>
<div class="btns">
  <button id="noise" type="button">{{btn_noise}}</button>
  <button id="decode" type="button">{{btn_decode}}</button>
  <button id="reset" type="button" class="ghost">{{btn_reset}}</button>
</div>

* { box-sizing: border-box; }
body { font-family: system-ui, sans-serif; color: #222; margin: 0; }
.hint { font-size: .9rem; color: #444; margin: 0 0 .7rem; line-height: 1.45; }
.msg { display: block; font-size: .9rem; font-weight: 600; margin: 0 0 .6rem; }
.msg input { font: 600 14px ui-monospace, monospace; padding: .35rem .5rem; margin-left: .4rem;
             border: 1px solid #adb1b8; border-radius: 6px; width: 8rem; text-transform: uppercase; }
.legend { display: flex; flex-wrap: wrap; gap: .8rem; font-size: .78rem; color: #444; margin: 0 0 .6rem; }
.legend span { display: inline-flex; align-items: center; gap: .3rem; }
.sw { width: 13px; height: 13px; border-radius: 3px; display: inline-block; border: 1px solid #99a; }
.sw.data { background: #e8eef3; } .sw.par { background: #fde8c4; }
.sw.flip { background: #e63946; } .sw.fix { background: #2a9d54; }
.grid { display: flex; flex-direction: column; gap: 5px; margin: .3rem 0 .6rem; }
.row { display: flex; gap: 5px; }
.bit { width: 38px; height: 38px; display: flex; align-items: center; justify-content: center;
       font: 700 16px ui-monospace, monospace; border-radius: 7px; border: 1px solid #cdd9e3; }
.bit.data { background: #e8eef3; color: #1d3557; }
.bit.par  { background: #fde8c4; color: #8a5a12; }
.bit.flip { background: #e63946; color: #fff; border-color: #c92f3c; }
.bit.fix  { background: #2a9d54; color: #fff; border-color: #1f7d41; }
.status { font-size: 1rem; font-weight: 600; margin: .5rem 0; min-height: 1.4em; }
.status.ok { color: #0a7d33; } .status.bad { color: #c92f3c; }
.btns { display: flex; gap: .5rem; flex-wrap: wrap; }
button { font: 600 14px system-ui, sans-serif; padding: .45rem .9rem; border: 1px solid #1d3557;
         background: #1d3557; color: #fff; border-radius: 8px; cursor: pointer; }
button.ghost { background: #fff; color: #1d3557; }

// Code not found

This little demo is a Hamming code, the great-grandparent of the modern families. Real LDPC and turbo codes do the same thing on a vastly larger scale: thousands of overlapping parity checks, decoded by passing "soft" probabilities back and forth until the bits settle on a consistent answer. The more checks overlap, the closer you can crowd against the noise.

What makes these codes special is not that they correct errors — every code does that — but how close to Shannon's limit they get, with decoding that's actually fast enough to run.

• LDPC (low-density parity-check). Invented by Robert Gallager in his 1962 MIT thesis, then ignored for thirty years as too costly for the hardware of the day. Rediscovered in the mid-1990s, they use a sparse web of parity checks decoded by belief propagation — bits and checks exchange probabilities until a consensus emerges. Well-designed LDPC codes land within ~0.0045 dB of capacity.
• Turbo codes. Announced by Berrou, Glavieux and Thitimajshima in 1993, they stunned the field by getting within ~0.5 dB of the limit. Their trick: two simple codes plus an interleaver, decoded by two sub-decoders that trade hints back and forth — the "turbo" feedback loop.
• Polar codes. Proved by Erdal Arikan in 2009 to provably achieve capacity as the block length grows — the first codes with a clean mathematical proof of optimality. They "polarize" a channel into nearly-perfect and nearly-useless sub-channels, then send data only on the good ones.

None of this is an open problem anymore. Shannon's limit is achieved, not merely approached in the polar case, and matched to within a hair in practice by LDPC. The hard part was never whether — Shannon settled that in 1948 — it was finding codes you can actually decode in real time, and these three families did it.

These codes are not lab curiosities — they are the invisible infrastructure of modern communication:

• 5G mobile. The standard uses LDPC for data channels and polar codes for control channels — the only commercial deployment of polar codes to date.
• Wi-Fi, satellite TV and Ethernet. LDPC powers Wi-Fi 6, the DVB-S2 satellite standard, and 10-gigabit Ethernet.
• Deep space. Turbo and LDPC codes let probes like the Mars rovers and the New Horizons mission send back images from billions of kilometers on a whisper of power.
• Storage. Modern hard drives and flash/SSD memory use LDPC to read data reliably off media that gets noisier as it shrinks.

Underneath them all sits the same idea that powers Reed–Solomon codes: add structured redundancy so the receiver can reconstruct what the channel destroyed — only here, pushed right up against the boundary set by Shannon entropy.

For half a century Shannon's limit was a promise no one could keep — a line everyone knew was reachable but no one could reach. Turbo, LDPC and polar codes kept the promise. Today we communicate within a fraction of a decibel of the absolute maximum that physics and information theory allow.

That is a rare thing in science: a problem fully solved. The next time your phone holds a call at the edge of coverage, or a rover beams a photo across the solar system, it is doing something Shannon proved was possible in 1948 and that took three brilliant ideas — and fifty years — to actually pull off. The same redundancy trick lives in Reed–Solomon codes; the limit it races against is Shannon entropy.